@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.20

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

@@ -1,8 +1,8 @@
 use crate::dvn_fee_lib::{
     apply_premium, get_call_data_size, DvnFeeLib, BPS_BASE, EXECUTE_FIXED_BYTES, NATIVE_DECIMALS_RATE, VERIFY_BYTES,
 };
+use fee_lib_interfaces::{DvnFeeParams, FeeEstimate, IDvnFeeLib};
 use soroban_sdk::{contract, contractimpl, testutils::Address as _, Address, Bytes, Env};
-use worker::{interfaces::FeeEstimate, DvnFeeParams, IDvnFeeLib};
 
 #[test]
 fn get_call_data_size_pads_signatures() {
@@ -108,8 +108,7 @@ fn get_fee_panics_when_options_not_empty() {
     env.mock_all_auths();
     let owner = Address::generate(&env);
     let fee_lib_addr = env.register(DvnFeeLib, (&owner,));
-    let mut options = Bytes::new(&env);
-    options.push_back(1u8);
+    let options = Bytes::from_slice(&env, &[1u8]);
 
     let params = DvnFeeParams {
         sender: Address::generate(&env),

package/contracts/workers/executor/Cargo.toml

@@ -19,6 +19,7 @@ soroban-sdk = { workspace = true }
 # workspace dependencies
 utils = { workspace = true }
 worker = { workspace = true }
+fee-lib-interfaces = { workspace = true }
 common-macros = { workspace = true }
 message-lib-common = { workspace = true }
 endpoint-v2 = { workspace = true, features = ["library"] }

package/contracts/workers/executor/src/executor.rs

@@ -7,12 +7,13 @@ use crate::{
 };
 use common_macros::{contract_impl, lz_contract};
 use endpoint_v2::{FeeRecipient, LayerZeroEndpointV2Client, Origin};
+use fee_lib_interfaces::{ExecutorFeeLibClient, FeeParams};
 use message_lib_common::interfaces::ILayerZeroExecutor;
 use soroban_sdk::{token::TokenClient, vec, Address, Bytes, BytesN, Env, Vec};
 use utils::{option_ext::OptionExt, upgradeable::UpgradeableInternal};
 use worker::{
-    assert_acl, assert_not_paused, assert_supported_message_lib, init_worker, require_admin_auth, set_admin_by_owner,
-    ExecutorFeeLibClient, FeeParams, Worker,
+    assert_acl, assert_not_paused, assert_supported_message_lib, errors::WorkerError, init_worker, require_admin_auth,
+    Worker,
 };
 
 /// LayerZero Executor contract for cross-chain message execution.
@@ -68,17 +69,6 @@ impl LzExecutor {
         require_admin_auth::<Self>(env, admin);
         TokenClient::new(env, token).transfer(&env.current_contract_address(), to, &amount);
     }
-
-    /// Sets admin status for an address. Requires owner authorization.
-    ///
-    /// This is the multisig/quorum path for admin management.
-    ///
-    /// # Arguments
-    /// * `admin` - The address to set admin status for
-    /// * `active` - Whether the address should be an admin
-    pub fn set_admin(env: &Env, admin: &Address, active: bool) {
-        set_admin_by_owner::<Self>(env, admin, active);
-    }
 }
 
 // ============================================================================
@@ -91,9 +81,7 @@ impl IExecutor for LzExecutor {
     fn set_dst_config(env: &Env, admin: &Address, params: &Vec<SetDstConfigParam>) {
         require_admin_auth::<Self>(env, admin);
 
-        for param in params {
-            ExecutorStorage::set_dst_config(env, param.dst_eid, &param.dst_config);
-        }
+        params.iter().for_each(|param| ExecutorStorage::set_dst_config(env, param.dst_eid, &param.dst_config));
         DstConfigSet { params: params.clone() }.publish(env);
     }
 
@@ -121,9 +109,9 @@ impl IExecutor for LzExecutor {
 
         // Transfer native tokens from admin to each receiver and track success/failure
         let mut success = vec![env];
-        for param in native_drop_params {
-            success.push_back(token_client.try_transfer(admin, &param.receiver, &param.amount).is_ok());
-        }
+        native_drop_params.iter().for_each(|param| {
+            success.push_back(token_client.try_transfer(admin, &param.receiver, &param.amount).is_ok())
+        });
 
         // Emit event with transfer results
         NativeDropApplied {
@@ -162,7 +150,8 @@ impl ILayerZeroExecutor for LzExecutor {
         // `get_fee` already asserts not_paused and acl, so we don't need to do it here again
 
         let fee = Self::get_fee(env, send_lib, sender, dst_eid, calldata_size, options);
-        FeeRecipient { amount: fee, to: Self::deposit_address(env) }
+        let deposit_address = Self::deposit_address(env).unwrap_or_panic(env, WorkerError::DepositAddressNotSet);
+        FeeRecipient { amount: fee, to: deposit_address }
     }
 
     /// Calculates the execution fee for a cross-chain message.
@@ -178,12 +167,14 @@ impl ILayerZeroExecutor for LzExecutor {
         assert_acl::<Self>(env, sender);
 
         let dst_config = Self::dst_config(env, dst_eid).unwrap_or_panic(env, ExecutorError::EidNotSupported);
+        let price_feed = Self::price_feed(env).unwrap_or_panic(env, WorkerError::PriceFeedNotSet);
+        let worker_fee_lib = Self::worker_fee_lib(env).unwrap_or_panic(env, WorkerError::WorkerFeeLibNotSet);
         let fee_params = FeeParams {
             sender: sender.clone(),
             dst_eid,
             calldata_size,
             options: options.clone(),
-            price_feed: Self::price_feed(env),
+            price_feed,
             default_multiplier_bps: Self::default_multiplier_bps(env),
             lz_receive_base_gas: dst_config.lz_receive_base_gas,
             lz_compose_base_gas: dst_config.lz_compose_base_gas,
@@ -192,7 +183,7 @@ impl ILayerZeroExecutor for LzExecutor {
             multiplier_bps: dst_config.multiplier_bps,
         };
 
-        ExecutorFeeLibClient::new(env, &Self::worker_fee_lib(env)).get_fee(&env.current_contract_address(), &fee_params)
+        ExecutorFeeLibClient::new(env, &worker_fee_lib).get_fee(&env.current_contract_address(), &fee_params)
     }
 }
 
@@ -207,12 +198,10 @@ impl Worker for LzExecutor {}
 // Upgradeable Implementation
 // ============================================================================
 
+/// No migration logic needed for initial upgrade capability
 impl UpgradeableInternal for LzExecutor {
     type MigrationData = ();
-
-    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
-        // No migration logic needed for initial upgrade capability
-    }
+    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {}
 }
 
 // ============================================================================

package/contracts/workers/executor-fee-lib/Cargo.toml

@@ -13,10 +13,11 @@ doctest = false
 soroban-sdk = { workspace = true }
 # workspace dependencies
 utils = { workspace = true }
-worker = { workspace = true }
+fee-lib-interfaces = { workspace = true }
 common-macros = { workspace = true }
 message-lib-common = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }
 

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

@@ -1,8 +1,8 @@
 use crate::{errors::ExecutorFeeLibError, executor_option};
 use common_macros::{contract_impl, lz_contract};
+use fee_lib_interfaces::{FeeParams, IExecutorFeeLib, LayerZeroPriceFeedClient};
 use soroban_sdk::{assert_with_error, Address, Bytes, Env};
 use utils::upgradeable::UpgradeableInternal;
-use worker::{FeeParams, IExecutorFeeLib, LayerZeroPriceFeedClient};
 
 // ============================================================================
 // Constants
@@ -110,12 +110,10 @@ impl IExecutorFeeLib for ExecutorFeeLib {
 // Upgradeable Implementation
 // ============================================================================
 
+/// No migration logic needed for initial upgrade capability
 impl UpgradeableInternal for ExecutorFeeLib {
     type MigrationData = ();
-
-    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
-        // No migration logic needed for initial upgrade capability
-    }
+    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {}
 }
 
 // ========================================================================
@@ -245,3 +243,63 @@ fn safe_u128_to_i128(env: &Env, value: u128) -> i128 {
     assert_with_error!(env, value <= i128::MAX as u128, ExecutorFeeLibError::Overflow);
     value as i128
 }
+
+// ============================================================================
+// Test-only Functions
+// ============================================================================
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    impl ExecutorFeeLib {
+        /// Test-only wrapper for `decode_executor_options` to enable unit testing.
+        pub fn decode_executor_options_for_test(
+            env: &Env,
+            options: &Bytes,
+            dst_eid: u32,
+            lz_receive_base_gas: u64,
+            lz_compose_base_gas: u64,
+            native_cap: u128,
+        ) -> (u128, u128) {
+            super::decode_executor_options(env, options, dst_eid, lz_receive_base_gas, lz_compose_base_gas, native_cap)
+        }
+
+        /// Test-only wrapper for `get_effective_multiplier_bps`.
+        pub fn get_effective_multiplier_bps_for_test(_env: &Env, params: &FeeParams) -> u32 {
+            super::get_effective_multiplier_bps(params)
+        }
+
+        /// Test-only wrapper for `apply_premium_to_gas`.
+        pub fn apply_premium_to_gas_for_test(
+            env: &Env,
+            fee: i128,
+            multiplier_bps: u32,
+            margin_usd: u128,
+            native_price_usd: u128,
+        ) -> i128 {
+            super::apply_premium_to_gas(env, fee, multiplier_bps, margin_usd, native_price_usd)
+        }
+
+        /// Test-only wrapper for `convert_and_apply_premium_to_value`.
+        pub fn convert_and_apply_premium_to_value_for_test(
+            env: &Env,
+            value: u128,
+            ratio: u128,
+            denom: u128,
+            multiplier_bps: u32,
+        ) -> i128 {
+            super::convert_and_apply_premium_to_value(env, value, ratio, denom, multiplier_bps)
+        }
+
+        /// Test-only wrapper for `is_v1_eid`.
+        pub fn is_v1_eid_for_test(_env: &Env, eid: u32) -> bool {
+            super::is_v1_eid(eid)
+        }
+
+        /// Test-only wrapper for `safe_u128_to_i128`.
+        pub fn safe_u128_to_i128_for_test(env: &Env, value: u128) -> i128 {
+            super::safe_u128_to_i128(env, value)
+        }
+    }
+}

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

@@ -80,7 +80,6 @@ pub fn parse_executor_options(env: &Env, options: &Bytes, is_v1_eid: bool, nativ
                 agg_options.num_lz_compose += 1;
             }
             EXECUTOR_OPTION_TYPE_ORDERED_EXECUTION => {
-                assert_with_error!(env, option_data.is_empty(), ExecutorFeeLibError::InvalidExecutorOptions);
                 agg_options.ordered = true;
             }
             _ => {
@@ -201,3 +200,31 @@ fn decode_lz_compose_option(env: &Env, option: &Bytes) -> (u16, u128, u128) {
 
     (index, gas, value)
 }
+
+// ========================================================
+// Test-only wrappers for internal helper functions
+// ========================================================
+//
+// These allow unit tests under `src/tests/...` (a sibling module of `executor_option`)
+// to exercise internal helpers without changing their visibility in production builds.
+#[cfg(test)]
+#[allow(dead_code)]
+pub(crate) mod test {
+    use super::*;
+
+    pub fn next_executor_option_for_test(reader: &mut BufferReader) -> (u8, Bytes) {
+        super::next_executor_option(reader)
+    }
+
+    pub fn decode_lz_receive_option_for_test(env: &Env, option: &Bytes) -> (u128, u128) {
+        super::decode_lz_receive_option(env, option)
+    }
+
+    pub fn decode_native_drop_option_for_test(env: &Env, option: &Bytes) -> (u128, BytesN<32>) {
+        super::decode_native_drop_option(env, option)
+    }
+
+    pub fn decode_lz_compose_option_for_test(env: &Env, option: &Bytes) -> (u16, u128, u128) {
+        super::decode_lz_compose_option(env, option)
+    }
+}

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

@@ -5,3 +5,6 @@ pub mod executor_fee_lib;
 pub mod executor_option;
 
 pub use executor_fee_lib::{ExecutorFeeLib, ExecutorFeeLibClient};
+
+#[cfg(test)]
+mod tests;