@layerzerolabs/protocol-stellar-v2 0.2.12 → 0.2.15

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

@@ -8,12 +8,14 @@
 use crate::{
     errors::DvnError, events::SetDstConfig, storage::DvnStorage, Call, DstConfig, DstConfigParam, IMultisig, IDVN,
 };
-use common_macros::{contract_impl, ttl_configurable};
+use common_macros::{contract_impl, ttl_configurable, upgradeable};
 use endpoint_v2::FeeRecipient;
 use message_lib_common::interfaces::ILayerZeroDVN;
+use soroban_sdk::panic_with_error;
 use soroban_sdk::{contract, xdr::ToXdr, Address, Bytes, BytesN, Env, Vec};
-use utils::buffer_writer::BufferWriter;
 use utils::option_ext::OptionExt;
+use utils::{buffer_writer::BufferWriter, ownable::Ownable};
+use utils::upgradeable::UpgradeableInternal;
 use worker::{
     assert_acl, assert_not_paused, assert_supported_message_lib, init_worker, require_admin_auth, set_admin_by_admin,
     set_admin_by_owner, DvnFeeLibClient, DvnFeeParams, Worker,
@@ -25,6 +27,7 @@ use worker::{
 /// The contract owns itself, allowing the multisig quorum to authorize operations.
 #[contract]
 #[ttl_configurable]
+#[upgradeable]
 pub struct LzDVN;
 
 // ============================================================================
@@ -58,7 +61,6 @@ impl LzDVN {
         deposit_address: &Address,
     ) {
         Self::init_multisig(env, signers, threshold);
-        Self::init_owner(env, &env.current_contract_address());
         init_worker::<Self>(
             env,
             admins,
@@ -200,9 +202,44 @@ impl ILayerZeroDVN for LzDVN {
 // Worker Implementation
 // ============================================================================
 
+/// Worker trait implementation using default methods for pause, admin, ACL, and fee configuration.
 #[contract_impl(contracttrait)]
 impl Worker for LzDVN {}
 
+// ============================================================================
+// Upgradeable Implementation
+// ============================================================================
+
+impl UpgradeableInternal for LzDVN {
+    type MigrationData = ();
+
+    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
+        // No migration logic needed for initial upgrade capability
+    }
+}
+
+// ============================================================================
+// Ownable impl for LzDVN
+// ============================================================================
+
+/// Self-owning contract: the DVN owns itself.
+///
+/// This allows multisig quorum approval to serve as owner authorization.
+/// Ownership transfer and renouncement are disabled since the contract is self-owned.
+impl Ownable for LzDVN {
+    fn owner(env: &Env) -> Option<Address> {
+        Some(env.current_contract_address())
+    }
+
+    fn transfer_ownership(env: &Env, _new_owner: &Address) {
+        panic_with_error!(env, DvnError::InvalidInvocation);
+    }
+
+    fn renounce_ownership(env: &Env) {
+        panic_with_error!(env, DvnError::InvalidInvocation);
+    }
+}
+
 // ============================================================================
 // Include SubModules
 // ============================================================================

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

@@ -5,6 +5,7 @@ pub enum DvnError {
     AuthDataExpired,
     EidNotSupported,
     HashAlreadyUsed,
+    InvalidInvocation,
     InvalidSigner,
     InvalidVid,
     NonContractInvoke,

package/contracts/workers/dvn/src/multisig.rs

@@ -10,6 +10,7 @@ use crate::{
     events::{SignerSet, ThresholdSet},
     storage::DvnStorage,
 };
+use common_macros::only_owner;
 use soroban_sdk::assert_with_error;
 
 // ============================================================================
@@ -18,9 +19,9 @@ use soroban_sdk::assert_with_error;
 
 #[contract_impl]
 impl IMultisig for LzDVN {
-    /// Adds or removes a signer. Requires contract self-authorization (quorum).
+    /// Adds or removes a signer. Requires multisig approval.
+    #[only_owner]
     fn set_signer(env: &Env, signer: &BytesN<20>, active: bool) {
-        env.current_contract_address().require_auth();
         if active {
             Self::add_signer(env, signer);
         } else {
@@ -28,10 +29,9 @@ impl IMultisig for LzDVN {
         }
     }
 
-    /// Updates the signature threshold. Requires contract self-authorization (quorum).
+    /// Updates the signature threshold. Requires multisig approval.
+    #[only_owner]
     fn set_threshold(env: &Env, threshold: u32) {
-        env.current_contract_address().require_auth();
-
         assert_with_error!(env, threshold > 0, DvnError::ZeroThreshold);
         assert_with_error!(env, Self::total_signers(env) >= threshold, DvnError::TotalSignersLessThanThreshold);
 
@@ -40,6 +40,10 @@ impl IMultisig for LzDVN {
         ThresholdSet { threshold }.publish(env);
     }
 
+    // ================================================================
+    // View Functions
+    // ================================================================
+
     /// Returns the list of all registered signers.
     fn get_signers(env: &Env) -> Vec<BytesN<20>> {
         DvnStorage::signers(env)
@@ -94,7 +98,7 @@ impl IMultisig for LzDVN {
 impl LzDVN {
     /// Initializes the multisig with a set of signers and threshold.
     /// Called during contract construction.
-    pub fn init_multisig(env: &Env, signers: &Vec<BytesN<20>>, threshold: u32) {
+    pub(super) fn init_multisig(env: &Env, signers: &Vec<BytesN<20>>, threshold: u32) {
         signers.iter().for_each(|signer| Self::add_signer(env, &signer));
         Self::set_threshold(env, threshold);
     }

package/contracts/workers/dvn/src/tests/multisig/set_threshold.rs

@@ -90,7 +90,7 @@ fn test_set_threshold_with_no_signers_fails() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #13)")] // DvnError::ZeroThreshold
+#[should_panic(expected = "Error(Contract, #14)")] // DvnError::ZeroThreshold
 fn test_constructor_threshold_zero_panics() {
     let env = Env::default();
     env.mock_all_auths();
@@ -99,7 +99,7 @@ fn test_constructor_threshold_zero_panics() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #11)")] // DvnError::TotalSignersLessThanThreshold
+#[should_panic(expected = "Error(Contract, #12)")] // DvnError::TotalSignersLessThanThreshold
 fn test_constructor_signers_less_than_threshold_panics() {
     let env = Env::default();
     env.mock_all_auths();

package/contracts/workers/dvn/src/tests/multisig/verify_signatures.rs

@@ -59,7 +59,7 @@ fn test_verify_signatures_raw_v_path() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #10)")] // DvnError::SignerNotFound
+#[should_panic(expected = "Error(Contract, #11)")] // DvnError::SignerNotFound
 fn test_verify_signatures_with_wrong_signer() {
     let setup = TestSetup::new(1);
     let digest = hash(&setup.env, b"test");
@@ -71,7 +71,7 @@ fn test_verify_signatures_with_wrong_signer() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #8)")] // DvnError::SignatureError
+#[should_panic(expected = "Error(Contract, #9)")] // DvnError::SignatureError
 fn test_verify_signatures_insufficient_signatures() {
     let setup = TestSetup::new(2);
     let digest = hash(&setup.env, b"insufficient");
@@ -82,7 +82,7 @@ fn test_verify_signatures_insufficient_signatures() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #12)")] // DvnError::UnsortedSigners
+#[should_panic(expected = "Error(Contract, #13)")] // DvnError::UnsortedSigners
 fn test_verify_signatures_duplicate_signer() {
     let setup = TestSetup::new(2);
     let digest = hash(&setup.env, b"duplicate");
@@ -94,7 +94,7 @@ fn test_verify_signatures_duplicate_signer() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #13)")] // DvnError::ZeroThreshold
+#[should_panic(expected = "Error(Contract, #14)")] // DvnError::ZeroThreshold
 fn test_verify_signatures_threshold_zero() {
     let setup = TestSetup::new(1);
     // Force threshold to 0 via storage to hit ZeroThreshold branch

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

@@ -10,11 +10,10 @@ library = []
 testutils = []
 
 [lib]
-crate-type = ["cdylib", "rlib"]
+crate-type = ["cdylib"]
 doctest = false
 
 [dependencies]
-cfg-if = "1.0"
 soroban-sdk = { workspace = true }
 common-macros = { workspace = true }
 message-lib-common = { workspace = true }

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

@@ -1,6 +1,7 @@
-use crate::DvnFeeLibError;
-use common_macros::contract_impl;
+use crate::errors::DvnFeeLibError;
+use common_macros::{contract_impl, ownable, ttl_configurable, upgradeable};
 use soroban_sdk::{assert_with_error, contract, Address, Env};
+use utils::upgradeable::UpgradeableInternal;
 use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 
 // ============================================================================
@@ -11,13 +12,13 @@ use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 pub(crate) const BPS_BASE: i128 = 10000;
 
 /// Fixed bytes for execute function call.
-pub(crate) const EXECUTE_FIXED_BYTES: u64 = 260;
+pub(crate) 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: u64 = 65;
+pub(crate) const SIGNATURE_RAW_BYTES: u32 = 65;
 
 /// Verify function bytes (padded).
-pub(crate) const VERIFY_BYTES: u64 = 288;
+pub(crate) 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;
@@ -28,29 +29,37 @@ pub(crate) const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
 /// and current gas prices from the price feed. Handles fee multipliers and
 /// floor margins.
 #[contract]
+#[ownable]
+#[ttl_configurable]
+#[upgradeable]
 pub struct DvnFeeLib;
 
+#[contract_impl]
+impl DvnFeeLib {
+    pub fn __constructor(env: &Env, owner: &Address) {
+        Self::init_owner(env, owner);
+    }
+}
+
 #[contract_impl]
 impl IDvnFeeLib for DvnFeeLib {
     fn get_fee(env: &Env, _dvn: &Address, params: &DvnFeeParams) -> i128 {
-        assert_with_error!(env, params.gas > 0, DvnFeeLibError::InvalidGas);
+        assert_with_error!(env, params.gas != 0, DvnFeeLibError::EidNotSupported);
         assert_with_error!(env, params.options.is_empty(), DvnFeeLibError::InvalidDVNOptions);
 
-        let call_data_size = get_call_data_size(params.quorum as u64);
-        let call_data_size_u32 =
-            u32::try_from(call_data_size).expect("call data size should comfortably fit into u32 for WASM");
+        let call_data_size = get_call_data_size(params.quorum);
 
         // Get estimated fee from price feed
         let price_feed_client = LayerZeroPriceFeedClient::new(env, &params.price_feed);
         let fee_result = price_feed_client.estimate_fee_by_eid(
             &env.current_contract_address(),
             &params.dst_eid,
-            &call_data_size_u32,
+            &call_data_size,
             &params.gas,
         );
-        assert_with_error!(env, fee_result.total_gas_fee >= 0, DvnFeeLibError::NegativeFee);
 
         apply_premium(
+            env,
             fee_result.total_gas_fee,
             params.multiplier_bps,
             params.default_multiplier_bps,
@@ -60,6 +69,18 @@ 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
 // ============================================================================
@@ -79,19 +100,24 @@ impl IDvnFeeLib for DvnFeeLib {
 /// # Returns
 /// Fee with premium applied (max of multiplier fee and margin fee).
 pub(crate) fn apply_premium(
+    env: &Env,
     fee: i128,
     multiplier_bps: u32,
     default_multiplier_bps: u32,
     floor_margin_usd: u128,
     native_price_usd: u128,
 ) -> i128 {
-    let effective_multiplier_bps = if multiplier_bps == 0 { default_multiplier_bps } else { multiplier_bps };
+    assert_with_error!(env, fee >= 0, DvnFeeLibError::InvalidFee);
 
+    let effective_multiplier_bps = if multiplier_bps == 0 { default_multiplier_bps } else { multiplier_bps };
     let fee_with_multiplier = fee * (effective_multiplier_bps as i128) / BPS_BASE;
     if native_price_usd == 0 || floor_margin_usd == 0 {
         return fee_with_multiplier;
     }
-    let fee_with_floor_margin = fee + (floor_margin_usd * NATIVE_DECIMALS_RATE / native_price_usd) as i128;
+
+    let floor_margin_in_native = safe_u128_to_i128(env, floor_margin_usd * NATIVE_DECIMALS_RATE / native_price_usd);
+    let fee_with_floor_margin = fee + floor_margin_in_native;
+
     fee_with_floor_margin.max(fee_with_multiplier)
 }
 
@@ -105,10 +131,16 @@ pub(crate) fn apply_premium(
 ///
 /// # Returns
 /// Total calldata size in bytes.
-pub(crate) fn get_call_data_size(quorum: u64) -> u64 {
+pub(crate) 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;
     }
     EXECUTE_FIXED_BYTES + VERIFY_BYTES + total_signature_bytes + 32
 }
+
+/// 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, DvnFeeLibError::Overflow);
+    value as i128
+}

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

@@ -2,7 +2,8 @@ use common_macros::contract_error;
 
 #[contract_error]
 pub enum DvnFeeLibError {
+    EidNotSupported,
     InvalidDVNOptions,
-    InvalidGas,
-    NegativeFee,
+    InvalidFee,
+    Overflow,
 }

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

@@ -1,17 +1,11 @@
 #![no_std]
-#[cfg(test)]
-extern crate std;
-
-mod errors;
 
-pub use errors::*;
+pub mod dvn_fee_lib;
+pub mod errors;
 
-cfg_if::cfg_if! {
-    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
-        mod dvn_fee_lib;
-        pub use dvn_fee_lib::DvnFeeLib;
-    }
-}
+pub use dvn_fee_lib::{DvnFeeLib, DvnFeeLibClient};
 
+#[cfg(test)]
+extern crate std;
 #[cfg(test)]
 mod tests;

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

@@ -18,66 +18,73 @@ fn get_call_data_size_pads_signatures() {
 
 #[test]
 fn apply_premium_multiplier_only_both_zero() {
+    let env = Env::default();
     let fee = 1_000i128;
     let multiplier_bps = 15_000u32;
     // multiplier_bps is non-zero, so default_multiplier_bps is ignored
-    let result = apply_premium(fee, multiplier_bps, 10_000, 0, 0);
+    let result = apply_premium(&env, fee, multiplier_bps, 10_000, 0, 0);
     assert_eq!(result, fee * multiplier_bps as i128 / BPS_BASE);
 }
 
 #[test]
 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(fee, multiplier_bps, 10_000, 100, 0);
+    let result = apply_premium(&env, fee, multiplier_bps, 10_000, 100, 0);
     assert_eq!(result, fee * multiplier_bps as i128 / BPS_BASE);
 }
 
 #[test]
 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(fee, multiplier_bps, 10_000, 0, NATIVE_DECIMALS_RATE);
+    let result = apply_premium(&env, fee, multiplier_bps, 10_000, 0, NATIVE_DECIMALS_RATE);
     assert_eq!(result, fee * multiplier_bps as i128 / BPS_BASE);
 }
 
 #[test]
 fn apply_premium_uses_default_when_multiplier_zero() {
+    let env = Env::default();
     let fee = 1_000i128;
     let default_bps = 12_000u32;
     // multiplier_bps is 0, so default_multiplier_bps should be used
-    let result = apply_premium(fee, 0, default_bps, 0, 0);
+    let result = apply_premium(&env, fee, 0, default_bps, 0, 0);
     assert_eq!(result, fee * default_bps as i128 / BPS_BASE);
 }
 
 #[test]
 fn apply_premium_floor_margin_wins() {
+    let env = Env::default();
     let fee = 1_000i128;
     let multiplier_bps = 10_000u32;
     let floor_margin_usd = 10u128;
     let native_price_usd = NATIVE_DECIMALS_RATE;
 
-    let result = apply_premium(fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
+    let result = apply_premium(&env, fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
     assert_eq!(result, fee + floor_margin_usd as i128);
 }
 
 #[test]
 fn apply_premium_multiplier_wins_over_small_floor() {
+    let env = Env::default();
     let fee = 1_000i128;
     let multiplier_bps = 12_000u32;
     let floor_margin_usd = 1u128;
     let native_price_usd = NATIVE_DECIMALS_RATE;
 
-    let result = apply_premium(fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
+    let result = apply_premium(&env, fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
     assert_eq!(result, 1_200);
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #2)")] // DvnFeeLibError::InvalidGas
+#[should_panic(expected = "Error(Contract, #1)")] // DvnFeeLibError::EidNotSupported
 fn get_fee_panics_when_gas_zero() {
     let env = Env::default();
     env.mock_all_auths();
-    let fee_lib_addr = env.register(DvnFeeLib, ());
+    let owner = Address::generate(&env);
+    let fee_lib_addr = env.register(DvnFeeLib, (&owner,));
     let params = DvnFeeParams {
         sender: Address::generate(&env),
         dst_eid: 1,
@@ -95,11 +102,12 @@ fn get_fee_panics_when_gas_zero() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #1)")] // DvnFeeLibError::InvalidDVNOptions
+#[should_panic(expected = "Error(Contract, #2)")] // DvnFeeLibError::InvalidDVNOptions
 fn get_fee_panics_when_options_not_empty() {
     let env = Env::default();
     env.mock_all_auths();
-    let fee_lib_addr = env.register(DvnFeeLib, ());
+    let owner = Address::generate(&env);
+    let fee_lib_addr = env.register(DvnFeeLib, (&owner,));
     let mut options = Bytes::new(&env);
     options.push_back(1u8);
 
@@ -171,7 +179,8 @@ impl MockPriceFeedNegative {
 fn get_fee_success_path() {
     let env = Env::default();
     env.mock_all_auths();
-    let fee_lib_addr = env.register(DvnFeeLib, ());
+    let owner = Address::generate(&env);
+    let fee_lib_addr = env.register(DvnFeeLib, (&owner,));
     let params = DvnFeeParams {
         sender: Address::generate(&env),
         dst_eid: 7,
@@ -194,7 +203,8 @@ fn get_fee_success_path() {
 fn get_fee_uses_default_multiplier_when_zero() {
     let env = Env::default();
     env.mock_all_auths();
-    let fee_lib_addr = env.register(DvnFeeLib, ());
+    let owner = Address::generate(&env);
+    let fee_lib_addr = env.register(DvnFeeLib, (&owner,));
 
     // multiplier_bps = 0, default_multiplier_bps = 12000 (1.2x)
     // MockPriceFeed returns fee=100, so result = 100 * 12000 / 10000 = 120
@@ -220,7 +230,8 @@ fn get_fee_uses_default_multiplier_when_zero() {
 fn get_fee_prefers_dst_multiplier_over_default() {
     let env = Env::default();
     env.mock_all_auths();
-    let fee_lib_addr = env.register(DvnFeeLib, ());
+    let owner = Address::generate(&env);
+    let fee_lib_addr = env.register(DvnFeeLib, (&owner,));
 
     // multiplier_bps = 15000 (1.5x), default_multiplier_bps = 10000 (1.0x)
     // MockPriceFeed returns fee=100, so result = 100 * 15000 / 10000 = 150
@@ -247,7 +258,8 @@ fn get_fee_prefers_dst_multiplier_over_default() {
 fn get_fee_panics_when_price_feed_returns_negative_fee() {
     let env = Env::default();
     env.mock_all_auths();
-    let fee_lib_addr = env.register(DvnFeeLib, ());
+    let owner = Address::generate(&env);
+    let fee_lib_addr = env.register(DvnFeeLib, (&owner,));
     let params = DvnFeeParams {
         sender: Address::generate(&env),
         dst_eid: 7,
@@ -267,18 +279,20 @@ fn get_fee_panics_when_price_feed_returns_negative_fee() {
 #[test]
 #[should_panic]
 fn apply_premium_panics_on_overflow() {
+    let env = Env::default();
     let fee = i128::MAX / 2;
     let multiplier_bps = 20_000u32;
-    apply_premium(fee, multiplier_bps, 10_000, u128::MAX, 1);
+    apply_premium(&env, fee, multiplier_bps, 10_000, u128::MAX, 1);
 }
 
 #[test]
 fn apply_premium_floor_margin_truncates() {
+    let env = Env::default();
     let fee = 0i128;
     let multiplier_bps = 10_000u32;
     let floor_margin_usd = 1u128;
     let native_price_usd = NATIVE_DECIMALS_RATE * 3 / 2;
 
-    let result = apply_premium(fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
+    let result = apply_premium(&env, fee, multiplier_bps, 10_000, floor_margin_usd, native_price_usd);
     assert_eq!(result, 0);
 }

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

@@ -5,12 +5,12 @@ use crate::{
     storage::ExecutorStorage,
     NativeDropParams,
 };
-use common_macros::{contract_impl, only_owner, ttl_configurable};
+use common_macros::{contract_impl, only_owner, ownable, ttl_configurable, upgradeable};
 use endpoint_v2::{FeeRecipient, LayerZeroEndpointV2Client, Origin};
 use message_lib_common::interfaces::ILayerZeroExecutor;
 use soroban_sdk::{contract, token::TokenClient, vec, Address, Bytes, BytesN, Env, Symbol, Vec};
 use utils::option_ext::OptionExt;
-use utils::ownable::Ownable;
+use utils::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,
@@ -19,6 +19,8 @@ use worker::{
 /// LayerZero Executor contract for cross-chain message execution.
 #[contract]
 #[ttl_configurable]
+#[upgradeable]
+#[ownable]
 pub struct LzExecutor;
 
 #[contract_impl]
@@ -227,6 +229,18 @@ 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-fee-lib/src/errors.rs

@@ -2,14 +2,16 @@ use common_macros::contract_error;
 
 #[contract_error]
 pub enum ExecutorFeeLibError {
+    EidNotSupported,
+    InvalidExecutorOptions,
+    InvalidFee,
+    InvalidLzComposeOption,
+    InvalidLzReceiveOption,
+    InvalidNativeDropOption,
+    NativeAmountExceedsCap,
     NoOptions,
+    Overflow,
     UnsupportedOptionType,
-    ZeroLzReceiveGasProvided,
     ZeroLzComposeGasProvided,
-    NativeAmountExceedsCap,
-    InvalidLzReceiveOption,
-    InvalidNativeDropOption,
-    InvalidLzComposeOption,
-    InvalidExecutorOptions,
-    EidNotSupported,
+    ZeroLzReceiveGasProvided,
 }