@layerzerolabs/protocol-stellar-v2 0.2.20 → 0.2.22

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

@@ -2,7 +2,6 @@ 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;
 
 // ============================================================================
 // Constants
@@ -25,7 +24,7 @@ const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
 /// Provides fee calculation logic based on executor options, destination configuration,
 /// and current gas prices from the price feed. Handles fee multipliers, margins, and
 /// native token value conversions.
-#[lz_contract(upgradeable)]
+#[lz_contract(upgradeable(no_migration))]
 pub struct ExecutorFeeLib;
 
 #[contract_impl]
@@ -106,16 +105,6 @@ 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) {}
-}
-
 // ========================================================================
 // Helper Functions
 // ========================================================================

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

@@ -1,10 +1,16 @@
 #![no_std]
 
 pub mod errors;
-pub mod executor_fee_lib;
 pub mod executor_option;
 
-pub use executor_fee_lib::{ExecutorFeeLib, ExecutorFeeLibClient};
+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 executor_fee_lib;
+        // Export the contract and client for testing purposes
+        pub use executor_fee_lib::{ExecutorFeeLib, ExecutorFeeLibClient};
+    }
+}
 
 #[cfg(test)]
 mod tests;

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

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

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

@@ -9,7 +9,12 @@ publish = false
 crate-type = ["cdylib", "rlib"]
 doctest = false
 
+[features]
+library = []
+testutils = []
+
 [dependencies]
+cfg-if = { workspace = true }
 soroban-sdk = { workspace = true }
 utils = { workspace = true }
 fee-lib-interfaces = { workspace = true }

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

@@ -1,13 +1,18 @@
 #![no_std]
 
-mod storage;
-
 pub mod errors;
 pub mod events;
-pub mod price_feed;
 pub mod types;
 
-pub use price_feed::{LzPriceFeed, LzPriceFeedClient};
+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 storage;
+        mod price_feed;
+        // Export the contract and client for testing purposes
+        pub use price_feed::{LzPriceFeed, LzPriceFeedClient};
+    }
+}
 
 #[cfg(test)]
 mod tests;

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

@@ -1,7 +1,6 @@
 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 utils::upgradeable::UpgradeableInternal;
 
 use crate::{
     errors::PriceFeedError,
@@ -10,7 +9,7 @@ use crate::{
     types::{ArbitrumPriceExt, ModelType, SetEidToModelTypeParam, UpdatePrice, UpdatePriceExt},
 };
 
-#[lz_contract(upgradeable)]
+#[lz_contract(upgradeable(no_migration))]
 pub struct LzPriceFeed;
 
 #[contract_impl]
@@ -267,12 +266,3 @@ impl LzPriceFeed {
     }
 }
 
-// ============================================================================
-// Upgradeable Implementation
-// ============================================================================
-
-/// No migration logic needed for initial upgrade capability
-impl UpgradeableInternal for LzPriceFeed {
-    type MigrationData = ();
-    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {}
-}

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

@@ -1,7 +1,7 @@
 use common_macros::contract_error;
 
 // Worker library error codes: 1200-1299
-// See ERROR_SPEC.md for allocation rules
+// See docs/error-spec.md for allocation rules
 
 /// WorkerError: 1200-1299
 #[contract_error]

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

@@ -1,6 +1,6 @@
 use soroban_sdk::{
     testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Bytes, Env, IntoVal, Val, Vec,
+    Address, Env, IntoVal, Val, Vec,
 };
 
 use crate::{init_worker, set_admin_by_admin, Worker};

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

@@ -1,5 +1,6 @@
 use super::setup::{bare_worker, TestSetup, WorkerTester};
 use crate::{
+    errors::WorkerError,
     events::{
         Paused, SetAdmin, SetAllowlist, SetDefaultMultiplierBps, SetDenylist, SetDepositAddress, SetPriceFeed,
         SetSupportedMessageLib, SetSupportedOptionTypes, SetWorkerFeeLib, Unpaused,
@@ -7,17 +8,16 @@ use crate::{
     init_worker,
 };
 use soroban_sdk::{testutils::Address as _, vec, Address, Bytes, Env, IntoVal};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 // pause
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1210)")] // WorkerError::PauseStatusUnchanged
 fn test_set_paused_rejects_unchanged_status() {
     let setup = TestSetup::new();
 
     setup.mock_owner_auth("set_paused", (false,));
-    setup.client.set_paused(&false);
+    assert_eq!(setup.client.try_set_paused(&false).unwrap_err().unwrap(), WorkerError::PauseStatusUnchanged.into());
 }
 
 #[test]
@@ -26,19 +26,18 @@ fn test_set_paused_toggles_state() {
 
     setup.mock_owner_auth("set_paused", (true,));
     setup.client.set_paused(&true);
-    assert_event(&setup.env, &setup.contract_id, Paused { pauser: setup.owner.clone() });
+    assert_eq_event(&setup.env, &setup.contract_id, Paused { pauser: setup.owner.clone() });
     assert_eq!(setup.client.paused(), true);
 
     setup.mock_owner_auth("set_paused", (false,));
     setup.client.set_paused(&false);
-    assert_event(&setup.env, &setup.contract_id, Unpaused { unpauser: setup.owner.clone() });
+    assert_eq_event(&setup.env, &setup.contract_id, Unpaused { unpauser: setup.owner.clone() });
     assert_eq!(setup.client.paused(), false);
 }
 
 // allowlist
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1202)")] // WorkerError::AlreadyOnAllowlist
 fn test_allowlist_rejects_duplicate_add() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
@@ -47,17 +46,19 @@ fn test_allowlist_rejects_duplicate_add() {
     setup.client.set_allowlist(&oapp, &true);
 
     setup.mock_owner_auth("set_allowlist", (&oapp, true));
-    setup.client.set_allowlist(&oapp, &true);
+    assert_eq!(
+        setup.client.try_set_allowlist(&oapp, &true).unwrap_err().unwrap(),
+        WorkerError::AlreadyOnAllowlist.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1208)")] // WorkerError::NotOnAllowlist
 fn test_allowlist_rejects_remove_missing() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
 
     setup.mock_owner_auth("set_allowlist", (&oapp, false));
-    setup.client.set_allowlist(&oapp, &false);
+    assert_eq!(setup.client.try_set_allowlist(&oapp, &false).unwrap_err().unwrap(), WorkerError::NotOnAllowlist.into());
 }
 
 #[test]
@@ -70,7 +71,7 @@ fn test_allowlist_remove_decrements_size_and_restores_default_acl() {
     assert_eq!(setup.client.is_on_allowlist(&oapp_a), false);
     setup.mock_owner_auth("set_allowlist", (&oapp_a, true));
     setup.client.set_allowlist(&oapp_a, &true);
-    assert_event(&setup.env, &setup.contract_id, SetAllowlist { oapp: oapp_a.clone(), allowed: true });
+    assert_eq_event(&setup.env, &setup.contract_id, SetAllowlist { oapp: oapp_a.clone(), allowed: true });
     assert_eq!(setup.client.is_on_allowlist(&oapp_a), true);
     assert_eq!(setup.client.allowlist_size(), 1);
     assert_eq!(setup.client.has_acl(&oapp_a), true);
@@ -79,7 +80,7 @@ fn test_allowlist_remove_decrements_size_and_restores_default_acl() {
     // Remove last allowlist entry => allowlist empty; default allows all (unless denylisted)
     setup.mock_owner_auth("set_allowlist", (&oapp_a, false));
     setup.client.set_allowlist(&oapp_a, &false);
-    assert_event(&setup.env, &setup.contract_id, SetAllowlist { oapp: oapp_a.clone(), allowed: false });
+    assert_eq_event(&setup.env, &setup.contract_id, SetAllowlist { oapp: oapp_a.clone(), allowed: false });
     assert_eq!(setup.client.is_on_allowlist(&oapp_a), false);
     assert_eq!(setup.client.allowlist_size(), 0);
     assert_eq!(setup.client.has_acl(&oapp_b), true);
@@ -88,7 +89,6 @@ fn test_allowlist_remove_decrements_size_and_restores_default_acl() {
 // denylist
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1203)")] // WorkerError::AlreadyOnDenylist
 fn test_denylist_rejects_duplicate_add() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
@@ -97,17 +97,19 @@ fn test_denylist_rejects_duplicate_add() {
     setup.client.set_denylist(&oapp, &true);
 
     setup.mock_owner_auth("set_denylist", (&oapp, true));
-    setup.client.set_denylist(&oapp, &true);
+    assert_eq!(
+        setup.client.try_set_denylist(&oapp, &true).unwrap_err().unwrap(),
+        WorkerError::AlreadyOnDenylist.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1209)")] // WorkerError::NotOnDenylist
 fn test_denylist_rejects_remove_missing() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
 
     setup.mock_owner_auth("set_denylist", (&oapp, false));
-    setup.client.set_denylist(&oapp, &false);
+    assert_eq!(setup.client.try_set_denylist(&oapp, &false).unwrap_err().unwrap(), WorkerError::NotOnDenylist.into());
 }
 
 // message_libs
@@ -122,7 +124,7 @@ fn test_message_lib_add_remove_and_errors() {
     // Add new supported lib
     setup.mock_owner_auth("set_supported_message_lib", (&new_lib, true));
     setup.client.set_supported_message_lib(&new_lib, &true);
-    assert_event(
+    assert_eq_event(
         &setup.env,
         &setup.contract_id,
         SetSupportedMessageLib { message_lib: new_lib.clone(), supported: true },
@@ -132,7 +134,7 @@ fn test_message_lib_add_remove_and_errors() {
     // Remove it
     setup.mock_owner_auth("set_supported_message_lib", (&new_lib, false));
     setup.client.set_supported_message_lib(&new_lib, &false);
-    assert_event(
+    assert_eq_event(
         &setup.env,
         &setup.contract_id,
         SetSupportedMessageLib { message_lib: new_lib.clone(), supported: false },
@@ -144,29 +146,32 @@ fn test_message_lib_add_remove_and_errors() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1205)")] // WorkerError::MessageLibAlreadySupported
 fn test_message_lib_rejects_duplicate_add() {
     let setup = TestSetup::new();
     let existing = setup.message_libs.get(0).unwrap();
 
     setup.mock_owner_auth("set_supported_message_lib", (&existing, true));
-    setup.client.set_supported_message_lib(&existing, &true);
+    assert_eq!(
+        setup.client.try_set_supported_message_lib(&existing, &true).unwrap_err().unwrap(),
+        WorkerError::MessageLibAlreadySupported.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1206)")] // WorkerError::MessageLibNotSupported
 fn test_message_lib_rejects_remove_missing() {
     let setup = TestSetup::new();
     let missing = Address::generate(&setup.env);
 
     setup.mock_owner_auth("set_supported_message_lib", (&missing, false));
-    setup.client.set_supported_message_lib(&missing, &false);
+    assert_eq!(
+        setup.client.try_set_supported_message_lib(&missing, &false).unwrap_err().unwrap(),
+        WorkerError::MessageLibNotSupported.into()
+    );
 }
 
 // admin-only setters
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1212)")] // WorkerError::Unauthorized
 fn test_admin_only_set_default_multiplier_requires_admin_membership() {
     let setup = TestSetup::new();
 
@@ -175,7 +180,10 @@ fn test_admin_only_set_default_multiplier_requires_admin_membership() {
 
     // Auth passes, but address isn't in admins list => Unauthorized
     setup.mock_auth(&non_admin, "set_default_multiplier_bps", (&non_admin, bps));
-    setup.client.set_default_multiplier_bps(&non_admin, &bps);
+    assert_eq!(
+        setup.client.try_set_default_multiplier_bps(&non_admin, &bps).unwrap_err().unwrap(),
+        WorkerError::Unauthorized.into()
+    );
 }
 
 #[test]
@@ -187,14 +195,14 @@ fn test_admin_setters_update_storage_and_events() {
     let bps = 12_000u32;
     setup.mock_auth(&admin, "set_default_multiplier_bps", (&admin, bps));
     setup.client.set_default_multiplier_bps(&admin, &bps);
-    assert_event(&setup.env, &setup.contract_id, SetDefaultMultiplierBps { multiplier_bps: bps });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDefaultMultiplierBps { multiplier_bps: bps });
     assert_eq!(setup.client.default_multiplier_bps(), bps);
 
     // set_deposit_address
     let new_deposit = Address::generate(&setup.env);
     setup.mock_auth(&admin, "set_deposit_address", (&admin, &new_deposit));
     setup.client.set_deposit_address(&admin, &new_deposit);
-    assert_event(&setup.env, &setup.contract_id, SetDepositAddress { deposit_address: new_deposit.clone() });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDepositAddress { deposit_address: new_deposit.clone() });
     assert_eq!(setup.client.deposit_address(), Some(new_deposit));
 
     // set_supported_option_types
@@ -204,7 +212,7 @@ fn test_admin_setters_update_storage_and_events() {
     let option_types = Bytes::from_slice(&setup.env, &[0xAA, 0xBB, 0xCC]);
     setup.mock_auth(&admin, "set_supported_option_types", (&admin, eid_a, option_types.clone()));
     setup.client.set_supported_option_types(&admin, &eid_a, &option_types);
-    assert_event(
+    assert_eq_event(
         &setup.env,
         &setup.contract_id,
         SetSupportedOptionTypes { dst_eid: eid_a, option_types: option_types.clone() },
@@ -217,14 +225,14 @@ fn test_admin_setters_update_storage_and_events() {
     let new_fee_lib = Address::generate(&setup.env);
     setup.mock_auth(&admin, "set_worker_fee_lib", (&admin, &new_fee_lib));
     setup.client.set_worker_fee_lib(&admin, &new_fee_lib);
-    assert_event(&setup.env, &setup.contract_id, SetWorkerFeeLib { fee_lib: new_fee_lib.clone() });
+    assert_eq_event(&setup.env, &setup.contract_id, SetWorkerFeeLib { fee_lib: new_fee_lib.clone() });
     assert_eq!(setup.client.worker_fee_lib(), Some(new_fee_lib));
 
     // set_price_feed
     let new_price_feed = Address::generate(&setup.env);
     setup.mock_auth(&admin, "set_price_feed", (&admin, &new_price_feed));
     setup.client.set_price_feed(&admin, &new_price_feed);
-    assert_event(&setup.env, &setup.contract_id, SetPriceFeed { price_feed: new_price_feed.clone() });
+    assert_eq_event(&setup.env, &setup.contract_id, SetPriceFeed { price_feed: new_price_feed.clone() });
     assert_eq!(setup.client.price_feed(), Some(new_price_feed));
 }
 
@@ -243,14 +251,14 @@ fn test_acl_allowlist_denylist_precedence() {
     assert_eq!(setup.client.is_on_denylist(&oapp_a), false);
     setup.mock_owner_auth("set_denylist", (&oapp_a, true));
     setup.client.set_denylist(&oapp_a, &true);
-    assert_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: true });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: true });
     assert_eq!(setup.client.is_on_denylist(&oapp_a), true);
     assert_eq!(setup.client.has_acl(&oapp_a), false);
 
     // Remove from denylist => allowed again (since allowlist is empty)
     setup.mock_owner_auth("set_denylist", (&oapp_a, false));
     setup.client.set_denylist(&oapp_a, &false);
-    assert_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: false });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: false });
     assert_eq!(setup.client.is_on_denylist(&oapp_a), false);
     assert_eq!(setup.client.has_acl(&oapp_a), true);
 
@@ -264,13 +272,13 @@ fn test_acl_allowlist_denylist_precedence() {
     // Denylist must override allowlist even for the same OApp.
     setup.mock_owner_auth("set_denylist", (&oapp_a, true));
     setup.client.set_denylist(&oapp_a, &true);
-    assert_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: true });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: true });
     assert_eq!(setup.client.has_acl(&oapp_a), false);
 
     // Removing from denylist should restore allowlist effect.
     setup.mock_owner_auth("set_denylist", (&oapp_a, false));
     setup.client.set_denylist(&oapp_a, &false);
-    assert_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: false });
+    assert_eq_event(&setup.env, &setup.contract_id, SetDenylist { oapp: oapp_a.clone(), denied: false });
     assert_eq!(setup.client.has_acl(&oapp_a), true);
 }
 
@@ -383,33 +391,37 @@ fn test_admin_management_by_owner_adds_and_removes_admin() {
 
     setup.mock_owner_auth("set_admin", (&new_admin, true));
     setup.client.set_admin(&new_admin, &true);
-    assert_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: true });
+    assert_eq_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: true });
     assert_eq!(setup.client.is_admin(&new_admin), true);
 
     setup.mock_owner_auth("set_admin", (&new_admin, false));
     setup.client.set_admin(&new_admin, &false);
-    assert_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: false });
+    assert_eq_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: false });
     assert_eq!(setup.client.is_admin(&new_admin), false);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1200)")] // WorkerError::AdminAlreadyExists
 fn test_admin_management_by_owner_rejects_duplicate_add() {
     let setup = TestSetup::new();
     let existing_admin = setup.admins.get(0).unwrap();
 
     setup.mock_owner_auth("set_admin", (&existing_admin, true));
-    setup.client.set_admin(&existing_admin, &true);
+    assert_eq!(
+        setup.client.try_set_admin(&existing_admin, &true).unwrap_err().unwrap(),
+        WorkerError::AdminAlreadyExists.into()
+    );
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1201)")] // WorkerError::AdminNotFound
 fn test_admin_management_by_owner_rejects_remove_missing_admin() {
     let setup = TestSetup::new();
     let missing_admin = Address::generate(&setup.env);
 
     setup.mock_owner_auth("set_admin", (&missing_admin, false));
-    setup.client.set_admin(&missing_admin, &false);
+    assert_eq!(
+        setup.client.try_set_admin(&missing_admin, &false).unwrap_err().unwrap(),
+        WorkerError::AdminNotFound.into()
+    );
 }
 
 #[test]
@@ -454,19 +466,21 @@ fn test_admin_management_by_admin_can_add_admin() {
 
     setup.mock_auth(&caller, "set_admin_by_admin_for_test", (&caller, &new_admin, true));
     setup.client.set_admin_by_admin_for_test(&caller, &new_admin, &true);
-    assert_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: true });
+    assert_eq_event(&setup.env, &setup.contract_id, SetAdmin { admin: new_admin.clone(), active: true });
     assert_eq!(setup.client.is_admin(&new_admin), true);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1212)")] // WorkerError::Unauthorized
 fn test_admin_management_by_admin_requires_caller_is_admin() {
     let setup = TestSetup::new();
     let non_admin = Address::generate(&setup.env);
     let new_admin = Address::generate(&setup.env);
 
     setup.mock_auth(&non_admin, "set_admin_by_admin_for_test", (&non_admin, &new_admin, true));
-    setup.client.set_admin_by_admin_for_test(&non_admin, &new_admin, &true);
+    assert_eq!(
+        setup.client.try_set_admin_by_admin_for_test(&non_admin, &new_admin, &true).unwrap_err().unwrap(),
+        WorkerError::Unauthorized.into()
+    );
 }
 
 #[test]