@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.20

package/contracts/workers/price-feed/src/tests/setup.rs

@@ -0,0 +1,70 @@
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    vec, Address, Env, IntoVal, Val, Vec,
+};
+
+use crate::{LzPriceFeed, LzPriceFeedClient};
+use fee_lib_interfaces::Price;
+
+// =============================================================================
+// Test Setup
+// =============================================================================
+
+pub struct TestSetup<'a> {
+    pub env: Env,
+    pub contract_id: Address,
+    pub client: LzPriceFeedClient<'a>,
+    pub owner: Address,
+    pub price_updater: Address,
+}
+
+impl<'a> TestSetup<'a> {
+    pub fn new() -> Self {
+        let env = Env::default();
+        let owner = Address::generate(&env);
+        let price_updater = Address::generate(&env);
+
+        let contract_id = env.register(LzPriceFeed, (&owner, &price_updater));
+        let client = LzPriceFeedClient::new(&env, &contract_id);
+
+        Self { env, contract_id, client, owner, price_updater }
+    }
+
+    pub fn mock_auth<T: IntoVal<Env, Vec<Val>>>(&self, address: &Address, fn_name: &str, args: T) {
+        self.env.mock_auths(&[MockAuth {
+            address,
+            invoke: &MockAuthInvoke {
+                contract: &self.contract_id,
+                fn_name,
+                args: args.into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+    }
+
+    pub fn mock_owner_auth<T: IntoVal<Env, Vec<Val>>>(&self, fn_name: &str, args: T) {
+        self.mock_auth(&self.owner, fn_name, args)
+    }
+
+    pub fn mock_price_updater_auth<T: IntoVal<Env, Vec<Val>>>(&self, fn_name: &str, args: T) {
+        self.mock_auth(&self.price_updater, fn_name, args)
+    }
+
+    /// Creates a default Price for testing
+    pub fn new_price(&self, price_ratio: u128, gas_price_in_unit: u64, gas_per_byte: u32) -> Price {
+        Price { price_ratio, gas_price_in_unit, gas_per_byte }
+    }
+
+    /// Creates a standard test price
+    pub fn default_test_price(&self) -> Price {
+        // price_ratio = 1e20 means 1:1 ratio
+        Price { price_ratio: 10u128.pow(20), gas_price_in_unit: 1_000_000, gas_per_byte: 16 }
+    }
+
+    /// Sets up a default model price for a destination EID
+    pub fn setup_default_price(&self, dst_eid: u32, price: &Price) {
+        let prices = vec![&self.env, crate::types::UpdatePrice { eid: dst_eid, price: price.clone() }];
+        self.mock_price_updater_auth("set_price", (&self.price_updater, &prices));
+        self.client.set_price(&self.price_updater, &prices);
+    }
+}

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

@@ -1,5 +1,5 @@
+use fee_lib_interfaces::Price;
 use soroban_sdk::contracttype;
-use worker::Price;
 
 /// Arbitrum-specific price extension
 #[contracttype]

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

@@ -10,17 +10,14 @@ pub enum WorkerError {
     AdminNotFound,
     AlreadyOnAllowlist,
     AlreadyOnDenylist,
-    AttemptingToRemoveOnlyAdmin,
     DepositAddressNotSet,
     MessageLibAlreadySupported,
     MessageLibNotSupported,
-    NoAdminsProvided,
     NotAllowed,
     NotOnAllowlist,
     NotOnDenylist,
     PauseStatusUnchanged,
     PriceFeedNotSet,
-    ReInitialize,
     Unauthorized,
     UnsupportedMessageLib,
     WorkerFeeLibNotSet,

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

@@ -2,12 +2,10 @@
 
 pub mod errors;
 pub mod events;
-pub mod interfaces;
 pub mod storage;
 
 mod worker;
 
-pub use interfaces::*;
 pub use worker::*;
 
 #[cfg(test)]

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

@@ -9,31 +9,16 @@ pub enum WorkerStorage {
     #[default(false)]
     Paused,
 
-    /// Address where worker fees are collected.
-    #[instance(Address)]
-    DepositAddress,
-
-    /// Price feed contract address for cross-chain fee calculations.
-    #[instance(Address)]
-    PriceFeed,
-
-    /// Worker fee library contract address for fee calculation logic.
-    #[instance(Address)]
-    WorkerFeeLib,
-
-    /// Default fee multiplier in basis points (10000 = 1x).
-    #[instance(u32)]
-    DefaultMultiplierBps,
-
-    /// Supported executor option types for a destination endpoint.
+    /// Admin addresses with configuration permissions.
     ///
-    /// Encoded bytes defining which option types (lzReceive, lzCompose, nativeDrop, etc.)
-    /// are supported for a specific destination chain.
-    #[persistent(Bytes)]
-    SupportedOptionTypes { eid: u32 },
+    /// Admins can modify worker settings but cannot change ownership.
+    #[persistent(Vec<Address>)]
+    #[default(Vec::new(env))]
+    Admins,
 
     /// List of supported message library addresses (e.g., ULN302).
     #[persistent(Vec<Address>)]
+    #[default(Vec::new(env))]
     MessageLibs,
 
     /// Allowlist status for an OApp address.
@@ -42,22 +27,40 @@ pub enum WorkerStorage {
     #[persistent(bool)]
     Allowlist { oapp: Address },
 
+    /// Counter for the number of addresses on the allowlist.
+    ///
+    /// Used to efficiently check if allowlist is empty (empty = allow all non-denylisted).
+    #[instance(u32)]
+    #[default(0)]
+    AllowlistSize,
+
     /// Denylist status for an OApp address.
     ///
     /// Denylisted OApps are blocked regardless of allowlist status.
     #[persistent(bool)]
     Denylist { oapp: Address },
 
-    /// Counter for the number of addresses on the allowlist.
-    ///
-    /// Used to efficiently check if allowlist is empty (empty = allow all non-denylisted).
+    /// Default fee multiplier in basis points (10000 = 1x).
     #[instance(u32)]
     #[default(0)]
-    AllowlistSize,
+    DefaultMultiplierBps,
 
-    /// Admin addresses with configuration permissions.
+    /// Address where worker fees are collected.
+    #[instance(Address)]
+    DepositAddress,
+
+    /// Supported executor option types for a destination endpoint.
     ///
-    /// Admins can modify worker settings but cannot change ownership.
-    #[persistent(Vec<Address>)]
-    Admins,
+    /// Since Stellar does not support Vec<u8>, we use Bytes instead where each byte
+    /// represents an option type (lzReceive, lzCompose, nativeDrop, etc.).
+    #[persistent(Bytes)]
+    SupportedOptionTypes { eid: u32 },
+
+    /// Worker fee library contract address for fee calculation logic.
+    #[instance(Address)]
+    WorkerFeeLib,
+
+    /// Price feed contract address for cross-chain fee calculations.
+    #[instance(Address)]
+    PriceFeed,
 }

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

@@ -3,7 +3,7 @@ use soroban_sdk::{
     Address, Bytes, Env, IntoVal, Val, Vec,
 };
 
-use crate::{init_worker, set_admin_by_admin, set_admin_by_owner, Worker};
+use crate::{init_worker, set_admin_by_admin, Worker};
 
 use common_macros::{contract_impl, ownable};
 use soroban_sdk::contract;
@@ -37,12 +37,6 @@ impl WorkerTester {
         );
     }
 
-    /// Test-only wrapper exposing `set_admin_by_owner` as a contract function
-    /// so we can exercise auth + storage updates in unit tests.
-    pub fn set_admin_by_owner_for_test(env: &Env, admin: &Address, active: bool) {
-        set_admin_by_owner::<Self>(env, admin, active);
-    }
-
     /// Test-only wrapper exposing `set_admin_by_admin` as a contract function
     /// so we can exercise auth + storage updates in unit tests.
     pub fn set_admin_by_admin_for_test(env: &Env, caller: &Address, admin: &Address, active: bool) {

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

@@ -12,7 +12,7 @@ use utils::testing_utils::assert_event;
 // pause
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1212)")] // WorkerError::PauseStatusUnchanged
+#[should_panic(expected = "Error(Contract, #1210)")] // WorkerError::PauseStatusUnchanged
 fn test_set_paused_rejects_unchanged_status() {
     let setup = TestSetup::new();
 
@@ -51,7 +51,7 @@ fn test_allowlist_rejects_duplicate_add() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1210)")] // WorkerError::NotOnAllowlist
+#[should_panic(expected = "Error(Contract, #1208)")] // WorkerError::NotOnAllowlist
 fn test_allowlist_rejects_remove_missing() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
@@ -101,7 +101,7 @@ fn test_denylist_rejects_duplicate_add() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1211)")] // WorkerError::NotOnDenylist
+#[should_panic(expected = "Error(Contract, #1209)")] // WorkerError::NotOnDenylist
 fn test_denylist_rejects_remove_missing() {
     let setup = TestSetup::new();
     let oapp = Address::generate(&setup.env);
@@ -144,7 +144,7 @@ fn test_message_lib_add_remove_and_errors() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1206)")] // WorkerError::MessageLibAlreadySupported
+#[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();
@@ -154,7 +154,7 @@ fn test_message_lib_rejects_duplicate_add() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1207)")] // WorkerError::MessageLibNotSupported
+#[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);
@@ -166,7 +166,7 @@ fn test_message_lib_rejects_remove_missing() {
 // admin-only setters
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1215)")] // WorkerError::Unauthorized
+#[should_panic(expected = "Error(Contract, #1212)")] // WorkerError::Unauthorized
 fn test_admin_only_set_default_multiplier_requires_admin_membership() {
     let setup = TestSetup::new();
 
@@ -195,7 +195,7 @@ fn test_admin_setters_update_storage_and_events() {
     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!(setup.client.deposit_address(), new_deposit);
+    assert_eq!(setup.client.deposit_address(), Some(new_deposit));
 
     // set_supported_option_types
     let eid_a = 1u32;
@@ -218,14 +218,14 @@ fn test_admin_setters_update_storage_and_events() {
     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!(setup.client.worker_fee_lib(), new_fee_lib);
+    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!(setup.client.price_feed(), new_price_feed);
+    assert_eq!(setup.client.price_feed(), Some(new_price_feed));
 }
 
 // view functions
@@ -277,30 +277,27 @@ fn test_acl_allowlist_denylist_precedence() {
 // uninitialized getters (BareWorker)
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1205)")] // WorkerError::DepositAddressNotSet
 fn test_view_panics_when_deposit_address_unset() {
     let env = Env::default();
     let owner = Address::generate(&env);
     let (_cid, client) = bare_worker(&env, &owner);
-    let _ = client.deposit_address();
+    assert_eq!(client.deposit_address(), None);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1213)")] // WorkerError::PriceFeedNotSet
 fn test_view_panics_when_price_feed_unset() {
     let env = Env::default();
     let owner = Address::generate(&env);
     let (_cid, client) = bare_worker(&env, &owner);
-    let _ = client.price_feed();
+    assert_eq!(client.price_feed(), None);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1217)")] // WorkerError::WorkerFeeLibNotSet
 fn test_view_panics_when_worker_fee_lib_unset() {
     let env = Env::default();
     let owner = Address::generate(&env);
     let (_cid, client) = bare_worker(&env, &owner);
-    let _ = client.worker_fee_lib();
+    assert_eq!(client.worker_fee_lib(), None);
 }
 
 #[test]
@@ -314,8 +311,7 @@ fn test_default_multiplier_bps_returns_zero_when_unset() {
 // init_worker / construction
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1208)")] // WorkerError::NoAdminsProvided
-fn test_init_worker_requires_non_empty_admins() {
+fn test_init_worker_allows_empty_admins() {
     let env = Env::default();
 
     let owner = Address::generate(&env);
@@ -326,29 +322,39 @@ fn test_init_worker_requires_non_empty_admins() {
     let deposit_address = Address::generate(&env);
     let default_multiplier_bps = 10_000u32;
 
-    // Panics inside __constructor via init_worker()
-    let _ = env.register(
+    // Empty admins is now allowed
+    let cid = env.register(
         WorkerTester,
         (&owner, &admins, &message_libs, &price_feed, &default_multiplier_bps, &worker_fee_lib, &deposit_address),
     );
+    let client = super::setup::WorkerTesterClient::new(&env, &cid);
+    assert_eq!(client.admins().len(), 0);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1214)")] // WorkerError::ReInitialize
-fn test_init_worker_cannot_reinitialize() {
+fn test_init_worker_can_reinitialize() {
     let setup = TestSetup::new();
+    let new_admin = Address::generate(&setup.env);
+    let new_admins = vec![&setup.env, new_admin.clone()];
+    let new_message_lib = Address::generate(&setup.env);
+    let new_message_libs = vec![&setup.env, new_message_lib.clone()];
 
+    // Re-initialization is allowed - adds new admins and message libs
     setup.as_contract(|| {
         init_worker::<WorkerTester>(
             &setup.env,
-            &setup.admins,
-            &setup.message_libs,
+            &new_admins,
+            &new_message_libs, // Use new message libs to avoid duplicate error
             &setup.price_feed,
             setup.default_multiplier_bps,
             &setup.worker_fee_lib,
             &setup.deposit_address,
         );
     });
+
+    // Verify new admin and message lib were added
+    assert!(setup.client.is_admin(&new_admin));
+    assert!(setup.client.is_supported_message_lib(&new_message_lib));
 }
 
 #[test]
@@ -358,9 +364,9 @@ fn test_init_worker_sets_config_and_defaults() {
     assert_eq!(setup.client.paused(), false);
     assert_eq!(setup.client.admins(), setup.admins);
     assert_eq!(setup.client.message_libs(), setup.message_libs);
-    assert_eq!(setup.client.price_feed(), setup.price_feed);
-    assert_eq!(setup.client.worker_fee_lib(), setup.worker_fee_lib);
-    assert_eq!(setup.client.deposit_address(), setup.deposit_address);
+    assert_eq!(setup.client.price_feed(), Some(setup.price_feed));
+    assert_eq!(setup.client.worker_fee_lib(), Some(setup.worker_fee_lib));
+    assert_eq!(setup.client.deposit_address(), Some(setup.deposit_address));
     assert_eq!(setup.client.default_multiplier_bps(), setup.default_multiplier_bps);
     assert_eq!(setup.client.allowlist_size(), 0);
 
@@ -375,13 +381,13 @@ fn test_admin_management_by_owner_adds_and_removes_admin() {
     let setup = TestSetup::new();
     let new_admin = Address::generate(&setup.env);
 
-    setup.mock_owner_auth("set_admin_by_owner_for_test", (&new_admin, true));
-    setup.client.set_admin_by_owner_for_test(&new_admin, &true);
+    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!(setup.client.is_admin(&new_admin), true);
 
-    setup.mock_owner_auth("set_admin_by_owner_for_test", (&new_admin, false));
-    setup.client.set_admin_by_owner_for_test(&new_admin, &false);
+    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!(setup.client.is_admin(&new_admin), false);
 }
@@ -392,8 +398,8 @@ 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_by_owner_for_test", (&existing_admin, true));
-    setup.client.set_admin_by_owner_for_test(&existing_admin, &true);
+    setup.mock_owner_auth("set_admin", (&existing_admin, true));
+    setup.client.set_admin(&existing_admin, &true);
 }
 
 #[test]
@@ -402,13 +408,12 @@ 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_by_owner_for_test", (&missing_admin, false));
-    setup.client.set_admin_by_owner_for_test(&missing_admin, &false);
+    setup.mock_owner_auth("set_admin", (&missing_admin, false));
+    setup.client.set_admin(&missing_admin, &false);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1204)")] // WorkerError::AttemptingToRemoveOnlyAdmin
-fn test_admin_management_cannot_remove_last_admin() {
+fn test_admin_management_can_remove_last_admin() {
     let env = Env::default();
     let owner = Address::generate(&env);
     let admins: soroban_sdk::Vec<Address> = vec![&env, Address::generate(&env)];
@@ -429,13 +434,16 @@ fn test_admin_management_cannot_remove_last_admin() {
         address: &owner,
         invoke: &soroban_sdk::testutils::MockAuthInvoke {
             contract: &cid,
-            fn_name: "set_admin_by_owner_for_test",
+            fn_name: "set_admin",
             args: (&only_admin, false).into_val(&env),
             sub_invokes: &[],
         },
     }]);
 
-    client.set_admin_by_owner_for_test(&only_admin, &false);
+    // Removing the last admin is now allowed
+    client.set_admin(&only_admin, &false);
+    assert_eq!(client.is_admin(&only_admin), false);
+    assert_eq!(client.admins().len(), 0);
 }
 
 #[test]
@@ -451,7 +459,7 @@ fn test_admin_management_by_admin_can_add_admin() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1215)")] // WorkerError::Unauthorized
+#[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);
@@ -462,7 +470,7 @@ fn test_admin_management_by_admin_requires_caller_is_admin() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1209)")] // WorkerError::NotAllowed
+#[should_panic(expected = "Error(Contract, #1207)")] // WorkerError::NotAllowed
 fn test_assert_acl_rejects_when_not_allowed() {
     let setup = TestSetup::new();
     let allowed = Address::generate(&setup.env);
@@ -478,7 +486,7 @@ fn test_assert_acl_rejects_when_not_allowed() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1216)")] // WorkerError::UnsupportedMessageLib
+#[should_panic(expected = "Error(Contract, #1213)")] // WorkerError::UnsupportedMessageLib
 fn test_assert_supported_message_lib_rejects_unsupported() {
     let setup = TestSetup::new();
     let unsupported = Address::generate(&setup.env);
@@ -489,7 +497,7 @@ fn test_assert_supported_message_lib_rejects_unsupported() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1218)")] // WorkerError::WorkerIsPaused
+#[should_panic(expected = "Error(Contract, #1215)")] // WorkerError::WorkerIsPaused
 fn test_assert_not_paused_panics_when_paused() {
     let setup = TestSetup::new();