@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

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

@@ -4,8 +4,8 @@ extern crate std;
 
 use crate::{dvn::LzDVN, tests::key_pair::KeyPair};
 use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, vec, Address, BytesN, Env, Vec};
-use utils::multisig::MultisigClient;
 use std::vec::Vec as StdVec;
+use utils::multisig::MultisigClient;
 
 pub const VID: u32 = 1;
 pub const DEFAULT_MULTIPLIER_BPS: u32 = 10000;
@@ -33,9 +33,7 @@ impl<'a> TestSetup<'a> {
         let key_pairs: StdVec<KeyPair> = (0..signer_count).map(|_| KeyPair::generate()).collect();
 
         let mut signers: Vec<BytesN<20>> = vec![&env];
-        for kp in &key_pairs {
-            signers.push_back(kp.signer(&env));
-        }
+        key_pairs.iter().for_each(|kp| signers.push_back(kp.signer(&env)));
 
         let admins: Vec<Address> = vec![&env, Address::generate(&env)];
         let supported_msglibs: Vec<Address> = vec![&env, Address::generate(&env)];
@@ -71,16 +69,14 @@ impl<'a> TestSetup<'a> {
         let key_pairs: StdVec<KeyPair> = (0..signer_count).map(|_| KeyPair::generate()).collect();
 
         let mut signers: Vec<BytesN<20>> = vec![&env];
-        for kp in &key_pairs {
-            signers.push_back(kp.signer(&env));
-        }
+        key_pairs.iter().for_each(|kp| signers.push_back(kp.signer(&env)));
 
         let mut admins: Vec<Address> = vec![&env, Address::generate(&env)];
-        for bytes in admin_bytes {
+        admin_bytes.into_iter().for_each(|bytes| {
             let bytes_n = BytesN::from_array(&env, &bytes);
             let addr = Address::from_payload(&env, AddressPayload::AccountIdPublicKeyEd25519(bytes_n));
             admins.push_back(addr);
-        }
+        });
 
         let supported_msglibs: Vec<Address> = vec![&env, Address::generate(&env)];
         let price_feed: Address = Address::generate(&env);

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

@@ -14,11 +14,11 @@ crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]
+cfg-if = { workspace = true }
 soroban-sdk = { workspace = true }
 common-macros = { workspace = true }
-message-lib-common = { workspace = true }
 utils = { workspace = true }
-worker = { workspace = true }
+fee-lib-interfaces = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }

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

@@ -1,34 +1,33 @@
 use crate::errors::DvnFeeLibError;
 use common_macros::{contract_impl, lz_contract};
+use fee_lib_interfaces::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 use soroban_sdk::{assert_with_error, Address, Env};
-use utils::upgradeable::UpgradeableInternal;
-use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 
 // ============================================================================
 // Constants
 // ============================================================================
 
 /// Basis points denominator (10000 = 100%).
-pub(crate) const BPS_BASE: i128 = 10000;
+const BPS_BASE: i128 = 10000;
 
 /// Fixed bytes for execute function call.
-pub(crate) const EXECUTE_FIXED_BYTES: u32 = 260;
+const EXECUTE_FIXED_BYTES: u32 = 260;
 
 /// Raw signature bytes length (65 bytes: 64 for signature + 1 for recovery ID).
-pub(crate) const SIGNATURE_RAW_BYTES: u32 = 65;
+const SIGNATURE_RAW_BYTES: u32 = 65;
 
 /// Verify function bytes (padded).
-pub(crate) const VERIFY_BYTES: u32 = 288;
+const VERIFY_BYTES: u32 = 288;
 
 /// Native token decimal rate for XLM (10^7 stroops per XLM).
-pub(crate) const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
+const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
 
 /// DVN fee library contract for calculating DVN verification fees.
 ///
 /// Provides fee calculation logic based on quorum size, destination gas costs,
 /// and current gas prices from the price feed. Handles fee multipliers and
 /// floor margins.
-#[lz_contract(upgradeable)]
+#[lz_contract(upgradeable(no_migration))]
 pub struct DvnFeeLib;
 
 #[contract_impl]
@@ -66,18 +65,6 @@ impl IDvnFeeLib for DvnFeeLib {
     }
 }
 
-// ============================================================================
-// Upgradeable Implementation
-// ============================================================================
-
-impl UpgradeableInternal for DvnFeeLib {
-    type MigrationData = ();
-
-    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
-        // No migration logic needed for initial upgrade capability
-    }
-}
-
 // ============================================================================
 // Internal Helper Functions
 // ============================================================================
@@ -96,7 +83,7 @@ impl UpgradeableInternal for DvnFeeLib {
 ///
 /// # Returns
 /// Fee with premium applied (max of multiplier fee and margin fee).
-pub(crate) fn apply_premium(
+fn apply_premium(
     env: &Env,
     fee: i128,
     multiplier_bps: u32,
@@ -128,7 +115,7 @@ pub(crate) fn apply_premium(
 ///
 /// # Returns
 /// Total calldata size in bytes.
-pub(crate) fn get_call_data_size(quorum: u32) -> u32 {
+fn get_call_data_size(quorum: u32) -> u32 {
     let mut total_signature_bytes = quorum * SIGNATURE_RAW_BYTES;
     if !total_signature_bytes.is_multiple_of(32) {
         total_signature_bytes = total_signature_bytes - (total_signature_bytes % 32) + 32;
@@ -141,3 +128,32 @@ fn safe_u128_to_i128(env: &Env, value: u128) -> i128 {
     assert_with_error!(env, value <= i128::MAX as u128, DvnFeeLibError::Overflow);
     value as i128
 }
+
+/// Test-only module exposing internal items for unit and integration tests.
+#[cfg(test)]
+pub(crate) mod test {
+    use super::*;
+
+    // Re-export constants for testing
+    pub const BPS_BASE: i128 = super::BPS_BASE;
+    pub const EXECUTE_FIXED_BYTES: u32 = super::EXECUTE_FIXED_BYTES;
+    pub const VERIFY_BYTES: u32 = super::VERIFY_BYTES;
+    pub const NATIVE_DECIMALS_RATE: u128 = super::NATIVE_DECIMALS_RATE;
+
+    /// Test-only wrapper for apply_premium to enable testing.
+    pub fn apply_premium_for_test(
+        env: &Env,
+        fee: i128,
+        multiplier_bps: u32,
+        default_multiplier_bps: u32,
+        floor_margin_usd: u128,
+        native_price_usd: u128,
+    ) -> i128 {
+        super::apply_premium(env, fee, multiplier_bps, default_multiplier_bps, floor_margin_usd, native_price_usd)
+    }
+
+    /// Test-only wrapper for get_call_data_size to enable testing.
+    pub fn get_call_data_size_for_test(quorum: u32) -> u32 {
+        super::get_call_data_size(quorum)
+    }
+}

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

@@ -1,9 +1,19 @@
 #![no_std]
 
-pub mod dvn_fee_lib;
 pub mod errors;
 
-pub use dvn_fee_lib::{DvnFeeLib, DvnFeeLibClient};
+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"))] {
+        mod dvn_fee_lib;
+        // Export the contract and client for testing purposes
+        pub use dvn_fee_lib::{DvnFeeLib, DvnFeeLibClient};
+    }
+}
+
+// Re-export test helpers module for integration tests
+#[cfg(test)]
+use dvn_fee_lib::test;
 
 #[cfg(test)]
 extern crate std;

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

@@ -1,18 +1,20 @@
-use crate::dvn_fee_lib::{
-    apply_premium, get_call_data_size, DvnFeeLib, BPS_BASE, EXECUTE_FIXED_BYTES, NATIVE_DECIMALS_RATE, VERIFY_BYTES,
+use crate::test::{
+    apply_premium_for_test, get_call_data_size_for_test, BPS_BASE, EXECUTE_FIXED_BYTES, NATIVE_DECIMALS_RATE,
+    VERIFY_BYTES,
 };
+use crate::DvnFeeLib;
+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() {
-    let size = get_call_data_size(1);
+    let size = get_call_data_size_for_test(1);
     assert_eq!(size, EXECUTE_FIXED_BYTES + VERIFY_BYTES + 96 + 32);
 
-    let size = get_call_data_size(2);
+    let size = get_call_data_size_for_test(2);
     assert_eq!(size, EXECUTE_FIXED_BYTES + VERIFY_BYTES + 160 + 32);
 
-    let size = get_call_data_size(32);
+    let size = get_call_data_size_for_test(32);
     assert_eq!(size, EXECUTE_FIXED_BYTES + VERIFY_BYTES + 2080 + 32);
 }
 
@@ -22,7 +24,7 @@ fn apply_premium_multiplier_only_both_zero() {
     let fee = 1_000i128;
     let multiplier_bps = 15_000u32;
     // multiplier_bps is non-zero, so default_multiplier_bps is ignored
-    let result = apply_premium(&env, fee, multiplier_bps, 10_000, 0, 0);
+    let result = apply_premium_for_test(&env, fee, multiplier_bps, 10_000, 0, 0);
     assert_eq!(result, fee * multiplier_bps as i128 / BPS_BASE);
 }
 
@@ -31,7 +33,7 @@ fn apply_premium_multiplier_only_native_price_zero() {
     let env = Env::default();
     let fee = 1_000i128;
     let multiplier_bps = 15_000u32;
-    let result = apply_premium(&env, fee, multiplier_bps, 10_000, 100, 0);
+    let result = apply_premium_for_test(&env, fee, multiplier_bps, 10_000, 100, 0);
     assert_eq!(result, fee * multiplier_bps as i128 / BPS_BASE);
 }
 
@@ -40,7 +42,7 @@ fn apply_premium_multiplier_only_floor_margin_zero() {
     let env = Env::default();
     let fee = 1_000i128;
     let multiplier_bps = 15_000u32;
-    let result = apply_premium(&env, fee, multiplier_bps, 10_000, 0, NATIVE_DECIMALS_RATE);
+    let result = apply_premium_for_test(&env, fee, multiplier_bps, 10_000, 0, NATIVE_DECIMALS_RATE);
     assert_eq!(result, fee * multiplier_bps as i128 / BPS_BASE);
 }
 
@@ -50,7 +52,7 @@ fn apply_premium_uses_default_when_multiplier_zero() {
     let fee = 1_000i128;
     let default_bps = 12_000u32;
     // multiplier_bps is 0, so default_multiplier_bps should be used
-    let result = apply_premium(&env, fee, 0, default_bps, 0, 0);
+    let result = apply_premium_for_test(&env, fee, 0, default_bps, 0, 0);
     assert_eq!(result, fee * default_bps as i128 / BPS_BASE);
 }
 
@@ -62,7 +64,7 @@ fn apply_premium_floor_margin_wins() {
     let floor_margin_usd = 10u128;
     let native_price_usd = NATIVE_DECIMALS_RATE;
 
-    let result = apply_premium(&env, fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
+    let result = apply_premium_for_test(&env, fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
     assert_eq!(result, fee + floor_margin_usd as i128);
 }
 
@@ -74,7 +76,7 @@ fn apply_premium_multiplier_wins_over_small_floor() {
     let floor_margin_usd = 1u128;
     let native_price_usd = NATIVE_DECIMALS_RATE;
 
-    let result = apply_premium(&env, fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
+    let result = apply_premium_for_test(&env, fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
     assert_eq!(result, 1_200);
 }
 
@@ -108,8 +110,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),
@@ -282,7 +283,7 @@ fn apply_premium_panics_on_overflow() {
     let env = Env::default();
     let fee = i128::MAX / 2;
     let multiplier_bps = 20_000u32;
-    apply_premium(&env, fee, multiplier_bps, 10_000, u128::MAX, 1);
+    apply_premium_for_test(&env, fee, multiplier_bps, 10_000, u128::MAX, 1);
 }
 
 #[test]
@@ -293,6 +294,6 @@ fn apply_premium_floor_margin_truncates() {
     let floor_margin_usd = 1u128;
     let native_price_usd = NATIVE_DECIMALS_RATE * 3 / 2;
 
-    let result = apply_premium(&env, fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
+    let result = apply_premium_for_test(&env, fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
     assert_eq!(result, 0);
 }

package/contracts/workers/executor/Cargo.toml

@@ -19,11 +19,15 @@ 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"] }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
+rand = { workspace = true }
+ed25519-dalek = { workspace = true }
+utils = { workspace = true, features = ["testutils"] }
 
 

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

@@ -7,16 +7,17 @@ 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 utils::option_ext::OptionExt;
 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.
-#[lz_contract(upgradeable)]
+#[lz_contract(upgradeable(no_migration))]
 pub struct LzExecutor;
 
 #[contract_impl]
@@ -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)
     }
 }
 
@@ -203,18 +194,6 @@ impl ILayerZeroExecutor for LzExecutor {
 #[contract_impl(contracttrait)]
 impl Worker for LzExecutor {}
 
-// ============================================================================
-// Upgradeable Implementation
-// ============================================================================
-
-impl UpgradeableInternal for LzExecutor {
-    type MigrationData = ();
-
-    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
-        // No migration logic needed for initial upgrade capability
-    }
-}
-
 // ============================================================================
 // Include SubModules
 // ============================================================================

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

@@ -16,5 +16,5 @@ cfg_if::cfg_if! {
     }
 }
 
-// #[cfg(test)]
-// mod tests;
+#[cfg(test)]
+mod tests;