@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

package/contracts/workers/executor-fee-lib/src/executor_fee_lib.rs

@@ -1,6 +1,7 @@
 use crate::{errors::ExecutorFeeLibError, executor_option};
-use common_macros::contract_impl;
+use common_macros::{contract_impl, ownable, ttl_configurable, upgradeable};
 use soroban_sdk::{assert_with_error, contract, Address, Bytes, Env};
+use utils::upgradeable::UpgradeableInternal;
 use worker::{FeeParams, IExecutorFeeLib, LayerZeroPriceFeedClient};
 
 // ============================================================================
@@ -11,7 +12,7 @@ use worker::{FeeParams, IExecutorFeeLib, LayerZeroPriceFeedClient};
 const V1_EID_THRESHOLD: u32 = 30000;
 
 /// Basis points denominator (10000 = 100%).
-const BPS_DENOMINATOR: i128 = 10000;
+const BPS_DENOMINATOR: u128 = 10000;
 
 /// Overhead percentage for ordered execution (102 = 2% overhead).
 const ORDERED_EXECUTION_OVERHEAD_PERCENT: u128 = 102;
@@ -25,123 +26,15 @@ const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
 /// and current gas prices from the price feed. Handles fee multipliers, margins, and
 /// native token value conversions.
 #[contract]
+#[ownable]
+#[ttl_configurable]
+#[upgradeable]
 pub struct ExecutorFeeLib;
 
 #[contract_impl]
 impl ExecutorFeeLib {
-    // ========================================================================
-    // Internal Functions
-    // ========================================================================
-
-    /// Decodes executor options and calculates total gas and native value.
-    ///
-    /// Parses encoded executor options, accumulates gas requirements (including
-    /// compose calls and ordered execution overhead), and returns the total native
-    /// value and gas needed.
-    ///
-    /// # Arguments
-    /// * `options` - Encoded executor options bytes
-    /// * `dst_eid` - Destination endpoint ID
-    /// * `lz_receive_base_gas` - Base gas for lzReceive execution
-    /// * `lz_compose_base_gas` - Base gas per lzCompose call
-    /// * `native_cap` - Maximum allowed native token value
-    ///
-    /// # Returns
-    /// Tuple of (total_native_value, total_gas).
-    fn decode_executor_options(
-        env: &Env,
-        options: &Bytes,
-        dst_eid: u32,
-        lz_receive_base_gas: u64,
-        lz_compose_base_gas: u64,
-        native_cap: u128,
-    ) -> (u128, u128) {
-        let options_agg = executor_option::parse_executor_options(env, options, Self::is_v1_eid(dst_eid), native_cap);
-
-        let mut total_gas = (lz_receive_base_gas as u128)
-            + options_agg.total_gas
-            + ((lz_compose_base_gas as u128) * (options_agg.num_lz_compose as u128));
-
-        if options_agg.ordered {
-            total_gas = (total_gas * ORDERED_EXECUTION_OVERHEAD_PERCENT) / 100;
-        }
-
-        (options_agg.total_value, total_gas)
-    }
-
-    /// Returns the effective multiplier in basis points.
-    ///
-    /// Uses destination-specific multiplier if set, otherwise falls back to default multiplier.
-    ///
-    /// # Arguments
-    /// * `params` - Fee parameters containing multiplier settings
-    ///
-    /// # Returns
-    /// Effective multiplier in basis points.
-    fn get_effective_multiplier_bps(params: &FeeParams) -> u32 {
-        if params.multiplier_bps == 0 {
-            params.default_multiplier_bps
-        } else {
-            params.multiplier_bps
-        }
-    }
-
-    /// Applies premium (multiplier and margin) to gas fee.
-    ///
-    /// Calculates fee with multiplier and floor margin, returning the maximum of both
-    /// to ensure profitability.
-    ///
-    /// # Arguments
-    /// * `fee` - Base gas fee
-    /// * `multiplier_bps` - Fee multiplier in basis points
-    /// * `margin_usd` - Minimum margin in USD (scaled)
-    /// * `native_price_usd` - Native token price in USD (scaled)
-    ///
-    /// # Returns
-    /// Fee with premium applied (max of multiplier fee and margin fee).
-    fn apply_premium_to_gas(fee: i128, multiplier_bps: u32, margin_usd: u128, native_price_usd: u128) -> i128 {
-        let fee_with_multiplier = (fee * multiplier_bps as i128) / BPS_DENOMINATOR;
-
-        if native_price_usd == 0 || margin_usd == 0 {
-            return fee_with_multiplier;
-        }
-
-        let fee_with_margin = ((margin_usd * NATIVE_DECIMALS_RATE) / native_price_usd) as i128 + fee;
-
-        fee_with_margin.max(fee_with_multiplier)
-    }
-
-    /// Converts native value and applies premium multiplier.
-    ///
-    /// Converts value using price ratio and applies multiplier in basis points.
-    ///
-    /// # Arguments
-    /// * `value` - Native value to convert
-    /// * `ratio` - Price ratio numerator
-    /// * `denom` - Price ratio denominator
-    /// * `multiplier_bps` - Fee multiplier in basis points
-    ///
-    /// # Returns
-    /// Converted and multiplied value, or 0 if input value is 0.
-    fn convert_and_apply_premium_to_value(value: u128, ratio: u128, denom: u128, multiplier_bps: u32) -> i128 {
-        if value == 0 {
-            return 0;
-        }
-        let converted = (value * ratio) / denom;
-        ((converted * multiplier_bps as u128) / BPS_DENOMINATOR as u128) as i128
-    }
-
-    /// Checks if an endpoint ID is a V1 endpoint.
-    ///
-    /// V1 endpoints (EID < 30000) have restrictions on executor options.
-    ///
-    /// # Arguments
-    /// * `eid` - Endpoint ID to check
-    ///
-    /// # Returns
-    /// `true` if the endpoint is a V1 endpoint, `false` otherwise.
-    fn is_v1_eid(eid: u32) -> bool {
-        eid < V1_EID_THRESHOLD
+    pub fn __constructor(env: &Env, owner: &Address) {
+        Self::init_owner(env, owner);
     }
 }
 
@@ -170,7 +63,7 @@ impl IExecutorFeeLib for ExecutorFeeLib {
     fn get_fee(env: &Env, _executor: &Address, params: &FeeParams) -> i128 {
         assert_with_error!(env, params.lz_receive_base_gas != 0, ExecutorFeeLibError::EidNotSupported);
 
-        let (total_value, total_gas) = Self::decode_executor_options(
+        let (total_value, total_gas) = decode_executor_options(
             env,
             &params.options,
             params.dst_eid,
@@ -186,16 +79,18 @@ impl IExecutorFeeLib for ExecutorFeeLib {
             &total_gas,
         );
 
-        let multiplier_bps = Self::get_effective_multiplier_bps(params);
+        let multiplier_bps = get_effective_multiplier_bps(params);
 
-        let mut fee = Self::apply_premium_to_gas(
+        let mut fee = apply_premium_to_gas(
+            env,
             fee_estimate.total_gas_fee,
             multiplier_bps,
             params.floor_margin_usd,
             fee_estimate.native_price_usd,
         );
 
-        fee += Self::convert_and_apply_premium_to_value(
+        fee += convert_and_apply_premium_to_value(
+            env,
             total_value,
             fee_estimate.price_ratio,
             fee_estimate.price_ratio_denominator,
@@ -213,3 +108,143 @@ impl IExecutorFeeLib for ExecutorFeeLib {
         (1, 1)
     }
 }
+
+// ============================================================================
+// Upgradeable Implementation
+// ============================================================================
+
+impl UpgradeableInternal for ExecutorFeeLib {
+    type MigrationData = ();
+
+    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
+        // No migration logic needed for initial upgrade capability
+    }
+}
+
+// ========================================================================
+// Helper Functions
+// ========================================================================
+
+/// Decodes executor options and calculates total gas and native value.
+///
+/// Parses encoded executor options, accumulates gas requirements (including
+/// compose calls and ordered execution overhead), and returns the total native
+/// value and gas needed.
+///
+/// # Arguments
+/// * `options` - Encoded executor options bytes
+/// * `dst_eid` - Destination endpoint ID
+/// * `lz_receive_base_gas` - Base gas for lzReceive execution
+/// * `lz_compose_base_gas` - Base gas per lzCompose call
+/// * `native_cap` - Maximum allowed native token value
+///
+/// # Returns
+/// Tuple of (total_native_value, total_gas).
+fn decode_executor_options(
+    env: &Env,
+    options: &Bytes,
+    dst_eid: u32,
+    lz_receive_base_gas: u64,
+    lz_compose_base_gas: u64,
+    native_cap: u128,
+) -> (u128, u128) {
+    let options_agg = executor_option::parse_executor_options(env, options, is_v1_eid(dst_eid), native_cap);
+
+    let mut total_gas = (lz_receive_base_gas as u128)
+        + options_agg.total_gas
+        + ((lz_compose_base_gas as u128) * (options_agg.num_lz_compose as u128));
+
+    if options_agg.ordered {
+        total_gas = (total_gas * ORDERED_EXECUTION_OVERHEAD_PERCENT) / 100;
+    }
+
+    (options_agg.total_value, total_gas)
+}
+
+/// Returns the effective multiplier in basis points.
+///
+/// Uses destination-specific multiplier if set, otherwise falls back to default multiplier.
+///
+/// # Arguments
+/// * `params` - Fee parameters containing multiplier settings
+///
+/// # Returns
+/// Effective multiplier in basis points.
+fn get_effective_multiplier_bps(params: &FeeParams) -> u32 {
+    if params.multiplier_bps == 0 {
+        params.default_multiplier_bps
+    } else {
+        params.multiplier_bps
+    }
+}
+
+/// Applies premium (multiplier and margin) to gas fee.
+///
+/// Calculates fee with multiplier and floor margin, returning the maximum of both
+/// to ensure profitability.
+///
+/// # Arguments
+/// * `fee` - Base gas fee
+/// * `multiplier_bps` - Fee multiplier in basis points
+/// * `margin_usd` - Minimum margin in USD (scaled)
+/// * `native_price_usd` - Native token price in USD (scaled)
+///
+/// # Example(scaled to 10^20)
+/// With margin_usd = $0.01 (0.01 * 10^20), native_price_usd = $0.32 (0.32 * 10^20), fee = 0:
+/// fee_with_margin = ((0.01 * 10^20 * 10^7) / (0.32 * 10^20)) + 0 = 312_500 stroops (0.03125 XLM)
+///
+/// # Returns
+/// Fee with premium applied (max of multiplier fee and margin fee).
+fn apply_premium_to_gas(env: &Env, fee: i128, multiplier_bps: u32, margin_usd: u128, native_price_usd: u128) -> i128 {
+    assert_with_error!(env, fee >= 0, ExecutorFeeLibError::InvalidFee);
+
+    let fee_with_multiplier = safe_u128_to_i128(env, (fee as u128 * multiplier_bps as u128) / BPS_DENOMINATOR);
+
+    if native_price_usd == 0 || margin_usd == 0 {
+        return fee_with_multiplier;
+    }
+
+    let margin_in_native = (margin_usd * NATIVE_DECIMALS_RATE) / native_price_usd;
+    let fee_with_margin = safe_u128_to_i128(env, margin_in_native) + fee;
+
+    fee_with_margin.max(fee_with_multiplier)
+}
+
+/// Converts native value and applies premium multiplier.
+///
+/// Converts value using price ratio and applies multiplier in basis points.
+///
+/// # Arguments
+/// * `value` - Native value to convert
+/// * `ratio` - Price ratio numerator
+/// * `denom` - Price ratio denominator
+/// * `multiplier_bps` - Fee multiplier in basis points
+///
+/// # Returns
+/// Converted and multiplied value, or 0 if input value is 0.
+fn convert_and_apply_premium_to_value(env: &Env, value: u128, ratio: u128, denom: u128, multiplier_bps: u32) -> i128 {
+    if value == 0 {
+        return 0;
+    }
+    let converted = (value * ratio) / denom;
+    safe_u128_to_i128(env, (converted * multiplier_bps as u128) / BPS_DENOMINATOR)
+}
+
+/// Checks if an endpoint ID is a V1 endpoint.
+///
+/// V1 endpoints (EID < 30000) have restrictions on executor options.
+///
+/// # Arguments
+/// * `eid` - Endpoint ID to check
+///
+/// # Returns
+/// `true` if the endpoint is a V1 endpoint, `false` otherwise.
+fn is_v1_eid(eid: u32) -> bool {
+    eid < V1_EID_THRESHOLD
+}
+
+/// Safely converts u128 to i128, panicking if value exceeds i128::MAX.
+fn safe_u128_to_i128(env: &Env, value: u128) -> i128 {
+    assert_with_error!(env, value <= i128::MAX as u128, ExecutorFeeLibError::Overflow);
+    value as i128
+}

package/contracts/workers/executor-helper/Cargo.toml

@@ -9,12 +9,7 @@ publish = false
 crate-type = ["cdylib"]
 doctest = false
 
-[features]
-library = []
-testutils = []
-
 [dependencies]
-cfg-if = { workspace = true }
 soroban-sdk = { workspace = true }
 # workspace dependencies
 common-macros = { workspace = true }

package/contracts/workers/executor-helper/src/lib.rs

@@ -2,10 +2,4 @@
 
 mod executor_helper;
 
-cfg_if::cfg_if! {
-    // Include implementation when NOT in library mode, OR when testutils is enabled (for tests)
-    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
-
-        pub use executor_helper::*;
-    }
-}
+pub use executor_helper::*;

package/contracts/workers/price-feed/Cargo.toml

@@ -11,7 +11,6 @@ doctest = false
 
 [dependencies]
 soroban-sdk = { workspace = true }
-endpoint-v2 = { workspace = true, features = ["library"] }
 utils = { workspace = true }
 worker = { workspace = true }
 common-macros = { workspace = true }

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

@@ -2,8 +2,9 @@ use common_macros::contract_error;
 
 #[contract_error]
 pub enum PriceFeedError {
-    OnlyPriceUpdater,
     InvalidDenominator,
-    NotAnOpStack,
     NoPrice,
+    NotAnOpStack,
+    OnlyPriceUpdater,
+    Overflow,
 }

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

@@ -1,11 +1,10 @@
 #![no_std]
 
-mod errors;
-mod events;
-mod price_feed;
 mod storage;
-mod types;
 
-pub use errors::*;
+pub mod errors;
+pub mod events;
+pub mod price_feed;
+pub mod types;
+
 pub use price_feed::{LzPriceFeed, LzPriceFeedClient};
-pub use types::*;

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

@@ -1,6 +1,6 @@
-use common_macros::{only_owner, ttl_configurable};
-use soroban_sdk::{assert_with_error, contract, contractimpl, panic_with_error, Address, Env, Vec};
-use utils::ownable::Ownable;
+use common_macros::{contract_impl, only_owner, ownable, ttl_configurable, upgradeable};
+use soroban_sdk::{assert_with_error, contract, panic_with_error, Address, Env, Vec};
+use utils::upgradeable::UpgradeableInternal;
 use worker::{FeeEstimate, ILayerZeroPriceFeed, Price};
 
 use crate::{
@@ -11,10 +11,12 @@ use crate::{
 };
 
 #[contract]
+#[ownable]
 #[ttl_configurable]
+#[upgradeable]
 pub struct LzPriceFeed;
 
-#[contractimpl]
+#[contract_impl]
 impl LzPriceFeed {
     pub fn __constructor(env: &Env, owner: &Address, price_updater: &Address) {
         Self::init_owner(env, owner);
@@ -23,7 +25,7 @@ impl LzPriceFeed {
     }
 }
 
-#[contractimpl]
+#[contract_impl]
 impl ILayerZeroPriceFeed for LzPriceFeed {
     /// Estimate fee with detailed breakdown by endpoint ID
     /// Corresponds to estimateFeeByEid in PriceFeed.sol
@@ -49,6 +51,8 @@ impl ILayerZeroPriceFeed for LzPriceFeed {
         let price_ratio_denominator = Self::get_price_ratio_denominator(env);
         let native_price_usd = Self::native_token_price_usd(env);
 
+        assert_with_error!(env, fee <= i128::MAX as u128, PriceFeedError::Overflow);
+
         FeeEstimate { total_gas_fee: fee as i128, price_ratio, price_ratio_denominator, native_price_usd }
     }
 
@@ -58,9 +62,8 @@ impl ILayerZeroPriceFeed for LzPriceFeed {
     }
 
     /// Get the price for a destination EID.
-    fn get_price(env: &Env, dst_eid: u32) -> Price {
+    fn get_price(env: &Env, dst_eid: u32) -> Option<Price> {
         PriceFeedStorage::default_model_price(env, dst_eid)
-            .unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice))
     }
 
     /// Get the price ratio denominator.
@@ -69,7 +72,7 @@ impl ILayerZeroPriceFeed for LzPriceFeed {
     }
 }
 
-#[contractimpl]
+#[contract_impl]
 impl LzPriceFeed {
     // ========================================================================
     // Owner Functions
@@ -78,7 +81,11 @@ impl LzPriceFeed {
     /// Set price updater status (owner only)
     #[only_owner]
     pub fn set_price_updater(env: &Env, updater: &Address, active: bool) {
-        PriceFeedStorage::set_price_updater(env, updater, &active);
+        if active {
+            PriceFeedStorage::set_price_updater(env, updater, &true);
+        } else {
+            PriceFeedStorage::remove_price_updater(env, updater);
+        }
         PriceUpdaterSet { updater: updater.clone(), active }.publish(env);
     }
 
@@ -141,8 +148,8 @@ impl LzPriceFeed {
     // ========================================================================
 
     /// Check if an address is an active price updater
-    pub fn price_updater(env: &Env, updater: &Address) -> bool {
-        PriceFeedStorage::price_updater(env, updater)
+    pub fn is_price_updater(env: &Env, updater: &Address) -> bool {
+        PriceFeedStorage::has_price_updater(env, updater)
     }
 
     /// Get the Arbitrum compression percent
@@ -172,7 +179,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);
+        let price = Self::get_price(env, dst_eid).unwrap_or_else(|| panic_with_error!(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);
@@ -187,13 +194,15 @@ impl LzPriceFeed {
         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);
+        let ethereum_price =
+            Self::get_price(env, ethereum_id).unwrap_or_else(|| panic_with_error!(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);
-        let gas_for_l2_calldata: u128 = (calldata_size as u128) * (optimism_price.gas_per_byte as u128);
+        let optimism_price =
+            Self::get_price(env, dst_eid).unwrap_or_else(|| panic_with_error!(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);
 
         let price_ratio_denom = Self::get_price_ratio_denominator(env);
@@ -206,7 +215,8 @@ 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);
+        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);
 
@@ -260,6 +270,18 @@ impl LzPriceFeed {
         }
 
         // Check if caller is an active price updater
-        assert_with_error!(env, Self::price_updater(env, caller), PriceFeedError::OnlyPriceUpdater);
+        assert_with_error!(env, Self::is_price_updater(env, caller), PriceFeedError::OnlyPriceUpdater);
+    }
+}
+
+// ============================================================================
+// Upgradeable Implementation
+// ============================================================================
+
+impl UpgradeableInternal for LzPriceFeed {
+    type MigrationData = ();
+
+    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
+        // No migration logic needed for initial upgrade capability
     }
 }

package/contracts/workers/worker/Cargo.toml

@@ -13,3 +13,7 @@ doctest = false
 soroban-sdk = { workspace = true }
 utils = { workspace = true }
 common-macros = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }

package/contracts/workers/worker/src/interfaces/price_feed.rs

@@ -49,7 +49,7 @@ pub trait ILayerZeroPriceFeed {
     /// Returns the USD price of the source chain native token.
     ///
     /// # Returns
-    /// Native token price in USD (scaled by appropriate decimals).
+    /// Native token price in USD (scaled by appropriate denominator).
     fn native_token_price_usd(env: &Env) -> u128;
 
     /// Returns gas price information for a destination endpoint.
@@ -58,8 +58,8 @@ pub trait ILayerZeroPriceFeed {
     /// * `dst_eid` - Destination endpoint ID (chain identifier)
     ///
     /// # Returns
-    /// `Price` containing price_ratio, gas_price_in_unit, and gas_per_byte.
-    fn get_price(env: &Env, dst_eid: u32) -> Price;
+    /// `Some(Price)` containing price_ratio, gas_price_in_unit, and gas_per_byte, or `None` if not set.
+    fn get_price(env: &Env, dst_eid: u32) -> Option<Price>;
 
     /// Returns the denominator used for price ratio calculations.
     ///

package/contracts/workers/worker/src/lib.rs

@@ -10,5 +10,5 @@ mod worker;
 pub use interfaces::*;
 pub use worker::*;
 
-// #[cfg(test)]
-// mod tests;
+#[cfg(test)]
+mod tests;

package/contracts/workers/worker/src/tests/mod.rs

@@ -0,0 +1,4 @@
+extern crate std;
+
+mod setup;
+mod worker;