@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,6 +1,6 @@
-use common_macros::{only_owner, ttl_configurable};
-use soroban_sdk::{assert_with_error, contract, contractimpl, panic_with_error, Address, Env, Vec};
-use utils::ownable::Ownable;
+use common_macros::{contract_impl, lz_contract, only_auth};
+use soroban_sdk::{assert_with_error, panic_with_error, Address, Env, Vec};
+use utils::upgradeable::UpgradeableInternal;
 use worker::{FeeEstimate, ILayerZeroPriceFeed, Price};
 
 use crate::{
@@ -10,11 +10,10 @@ use crate::{
     types::{ArbitrumPriceExt, ModelType, SetEidToModelTypeParam, UpdatePrice, UpdatePriceExt},
 };
 
-#[contract]
-#[ttl_configurable]
+#[lz_contract(upgradeable)]
 pub struct LzPriceFeed;
 
-#[contractimpl]
+#[contract_impl]
 impl LzPriceFeed {
     pub fn __constructor(env: &Env, owner: &Address, price_updater: &Address) {
         Self::init_owner(env, owner);
@@ -23,7 +22,7 @@ impl LzPriceFeed {
     }
 }
 
-#[contractimpl]
+#[contract_impl]
 impl ILayerZeroPriceFeed for LzPriceFeed {
     /// Estimate fee with detailed breakdown by endpoint ID
     /// Corresponds to estimateFeeByEid in PriceFeed.sol
@@ -49,6 +48,8 @@ impl ILayerZeroPriceFeed for LzPriceFeed {
         let price_ratio_denominator = Self::get_price_ratio_denominator(env);
         let native_price_usd = Self::native_token_price_usd(env);
 
+        assert_with_error!(env, fee <= i128::MAX as u128, PriceFeedError::Overflow);
+
         FeeEstimate { total_gas_fee: fee as i128, price_ratio, price_ratio_denominator, native_price_usd }
     }
 
@@ -58,9 +59,8 @@ impl ILayerZeroPriceFeed for LzPriceFeed {
     }
 
     /// Get the price for a destination EID.
-    fn get_price(env: &Env, dst_eid: u32) -> Price {
+    fn get_price(env: &Env, dst_eid: u32) -> Option<Price> {
         PriceFeedStorage::default_model_price(env, dst_eid)
-            .unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice))
     }
 
     /// Get the price ratio denominator.
@@ -69,34 +69,38 @@ impl ILayerZeroPriceFeed for LzPriceFeed {
     }
 }
 
-#[contractimpl]
+#[contract_impl]
 impl LzPriceFeed {
     // ========================================================================
     // Owner Functions
     // ========================================================================
 
     /// Set price updater status (owner only)
-    #[only_owner]
+    #[only_auth]
     pub fn set_price_updater(env: &Env, updater: &Address, active: bool) {
-        PriceFeedStorage::set_price_updater(env, updater, &active);
+        if active {
+            PriceFeedStorage::set_price_updater(env, updater, &true);
+        } else {
+            PriceFeedStorage::remove_price_updater(env, updater);
+        }
         PriceUpdaterSet { updater: updater.clone(), active }.publish(env);
     }
 
     /// Set the price ratio denominator (owner only)
-    #[only_owner]
+    #[only_auth]
     pub fn set_price_ratio_denominator(env: &Env, denominator: u128) {
         assert_with_error!(env, denominator > 0, PriceFeedError::InvalidDenominator);
         PriceFeedStorage::set_price_ratio_denominator(env, &denominator);
     }
 
     /// Set the Arbitrum compression percentage (owner only)
-    #[only_owner]
+    #[only_auth]
     pub fn set_arbitrum_compression_percent(env: &Env, compression_percent: u128) {
         PriceFeedStorage::set_arbitrum_compression_percent(env, &compression_percent);
     }
 
     /// Set the fee model type for destination EIDs (owner only)
-    #[only_owner]
+    #[only_auth]
     pub fn set_eid_to_model_type(env: &Env, params: &Vec<SetEidToModelTypeParam>) {
         for param in params.iter() {
             PriceFeedStorage::set_eid_to_model_type(env, param.dst_eid, &param.model_type);
@@ -141,8 +145,8 @@ impl LzPriceFeed {
     // ========================================================================
 
     /// Check if an address is an active price updater
-    pub fn price_updater(env: &Env, updater: &Address) -> bool {
-        PriceFeedStorage::price_updater(env, updater)
+    pub fn is_price_updater(env: &Env, updater: &Address) -> bool {
+        PriceFeedStorage::has_price_updater(env, updater)
     }
 
     /// Get the Arbitrum compression percent
@@ -172,7 +176,7 @@ impl LzPriceFeed {
 
     /// Estimate fee with default model
     fn estimate_fee_with_default_model(env: &Env, dst_eid: u32, calldata_size: u32, gas: u128) -> (u128, u128) {
-        let price = Self::get_price(env, dst_eid);
+        let price = Self::get_price(env, dst_eid).unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice));
 
         // assuming the _gas includes (1) the 21,000 overhead and (2) not the calldata gas
         let gas_for_calldata = (calldata_size as u128) * (price.gas_per_byte as u128);
@@ -187,13 +191,15 @@ impl LzPriceFeed {
         let ethereum_id = Self::get_l1_lookup_id_for_optimism_model(env, dst_eid);
 
         // L1 fee (Ethereum)
-        let ethereum_price = Self::get_price(env, ethereum_id);
+        let ethereum_price =
+            Self::get_price(env, ethereum_id).unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice));
         let gas_for_l1_calldata = ((calldata_size as u128) * (ethereum_price.gas_per_byte as u128)) + 3188; // 2100 + 68 * 16
         let l1_fee = gas_for_l1_calldata * (ethereum_price.gas_price_in_unit as u128);
 
         // L2 fee (Optimism)
-        let optimism_price = Self::get_price(env, dst_eid);
-        let gas_for_l2_calldata: u128 = (calldata_size as u128) * (optimism_price.gas_per_byte as u128);
+        let optimism_price =
+            Self::get_price(env, dst_eid).unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice));
+        let gas_for_l2_calldata = (calldata_size as u128) * (optimism_price.gas_per_byte as u128);
         let l2_fee = (gas_for_l2_calldata + gas) * (optimism_price.gas_price_in_unit as u128);
 
         let price_ratio_denom = Self::get_price_ratio_denominator(env);
@@ -206,7 +212,8 @@ impl LzPriceFeed {
 
     /// Estimate fee with Arbitrum model
     fn estimate_fee_with_arbitrum_model(env: &Env, dst_eid: u32, calldata_size: u32, gas: u128) -> (u128, u128) {
-        let arbitrum_price = Self::get_price(env, dst_eid);
+        let arbitrum_price =
+            Self::get_price(env, dst_eid).unwrap_or_else(|| panic_with_error!(env, PriceFeedError::NoPrice));
 
         let arbitrum_price_ext = Self::arbitrum_price_ext(env);
 
@@ -260,6 +267,18 @@ impl LzPriceFeed {
         }
 
         // Check if caller is an active price updater
-        assert_with_error!(env, Self::price_updater(env, caller), PriceFeedError::OnlyPriceUpdater);
+        assert_with_error!(env, Self::is_price_updater(env, caller), PriceFeedError::OnlyPriceUpdater);
+    }
+}
+
+// ============================================================================
+// Upgradeable Implementation
+// ============================================================================
+
+impl UpgradeableInternal for LzPriceFeed {
+    type MigrationData = ();
+
+    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
+        // No migration logic needed for initial upgrade capability
     }
 }

package/contracts/workers/worker/Cargo.toml

@@ -13,3 +13,7 @@ doctest = false
 soroban-sdk = { workspace = true }
 utils = { workspace = true }
 common-macros = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }

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

@@ -1,5 +1,9 @@
 use common_macros::contract_error;
 
+// Worker library error codes: 1200-1299
+// See ERROR_SPEC.md for allocation rules
+
+/// WorkerError: 1200-1299
 #[contract_error]
 pub enum WorkerError {
     AdminAlreadyExists = 1200,

package/contracts/workers/worker/src/interfaces/price_feed.rs

@@ -49,7 +49,7 @@ pub trait ILayerZeroPriceFeed {
     /// Returns the USD price of the source chain native token.
     ///
     /// # Returns
-    /// Native token price in USD (scaled by appropriate decimals).
+    /// Native token price in USD (scaled by appropriate denominator).
     fn native_token_price_usd(env: &Env) -> u128;
 
     /// Returns gas price information for a destination endpoint.
@@ -58,8 +58,8 @@ pub trait ILayerZeroPriceFeed {
     /// * `dst_eid` - Destination endpoint ID (chain identifier)
     ///
     /// # Returns
-    /// `Price` containing price_ratio, gas_price_in_unit, and gas_per_byte.
-    fn get_price(env: &Env, dst_eid: u32) -> Price;
+    /// `Some(Price)` containing price_ratio, gas_price_in_unit, and gas_per_byte, or `None` if not set.
+    fn get_price(env: &Env, dst_eid: u32) -> Option<Price>;
 
     /// Returns the denominator used for price ratio calculations.
     ///

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

@@ -10,5 +10,5 @@ mod worker;
 pub use interfaces::*;
 pub use worker::*;
 
-// #[cfg(test)]
-// mod tests;
+#[cfg(test)]
+mod tests;

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

@@ -0,0 +1,4 @@
+extern crate std;
+
+mod setup;
+mod worker;

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

@@ -0,0 +1,147 @@
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Bytes, Env, IntoVal, Val, Vec,
+};
+
+use crate::{init_worker, set_admin_by_admin, set_admin_by_owner, Worker};
+
+use common_macros::{contract_impl, ownable};
+use soroban_sdk::contract;
+
+#[contract]
+#[ownable]
+pub struct WorkerTester;
+
+#[contract_impl]
+impl WorkerTester {
+    #[allow(clippy::too_many_arguments)]
+    pub fn __constructor(
+        env: &Env,
+        owner: &Address,
+        admins: &Vec<Address>,
+        message_libs: &Vec<Address>,
+        price_feed: &Address,
+        default_multiplier_bps: u32,
+        worker_fee_lib: &Address,
+        deposit_address: &Address,
+    ) {
+        Self::init_owner(env, owner);
+        init_worker::<Self>(
+            env,
+            admins,
+            message_libs,
+            price_feed,
+            default_multiplier_bps,
+            worker_fee_lib,
+            deposit_address,
+        );
+    }
+
+    /// 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) {
+        set_admin_by_admin::<Self>(env, caller, admin, active);
+    }
+}
+
+#[contract_impl(contracttrait)]
+impl Worker for WorkerTester {}
+
+mod bare_worker_contract {
+    use super::*;
+
+    #[contract]
+    #[ownable]
+    pub struct BareWorker;
+
+    #[contract_impl]
+    impl BareWorker {
+        pub fn __constructor(env: &Env, owner: &Address) {
+            Self::init_owner(env, owner);
+        }
+    }
+
+    #[contract_impl(contracttrait)]
+    impl Worker for BareWorker {}
+}
+
+pub struct TestSetup<'a> {
+    pub env: Env,
+    pub contract_id: Address,
+    pub client: WorkerTesterClient<'a>,
+    pub owner: Address,
+    pub admins: Vec<Address>,
+    pub message_libs: Vec<Address>,
+    pub price_feed: Address,
+    pub worker_fee_lib: Address,
+    pub deposit_address: Address,
+    pub default_multiplier_bps: u32,
+}
+
+impl<'a> TestSetup<'a> {
+    pub fn new() -> Self {
+        let env = Env::default();
+
+        let owner = Address::generate(&env);
+        let admins: Vec<Address> = soroban_sdk::vec![&env, Address::generate(&env), Address::generate(&env)];
+        let message_libs: Vec<Address> = soroban_sdk::vec![&env, Address::generate(&env)];
+        let price_feed = Address::generate(&env);
+        let worker_fee_lib = Address::generate(&env);
+        let deposit_address = Address::generate(&env);
+        let default_multiplier_bps = 10_000;
+
+        let contract_id = env.register(
+            WorkerTester,
+            (&owner, &admins, &message_libs, &price_feed, &default_multiplier_bps, &worker_fee_lib, &deposit_address),
+        );
+        let client = WorkerTesterClient::new(&env, &contract_id);
+
+        Self {
+            env,
+            contract_id,
+            client,
+            owner,
+            admins,
+            message_libs,
+            price_feed,
+            worker_fee_lib,
+            deposit_address,
+            default_multiplier_bps,
+        }
+    }
+
+    pub fn as_contract<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce() -> R,
+    {
+        self.env.as_contract(&self.contract_id, f)
+    }
+
+    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 bare_worker<'a>(env: &'a Env, owner: &Address) -> (Address, bare_worker_contract::BareWorkerClient<'a>) {
+    let contract_id = env.register(bare_worker_contract::BareWorker, (owner,));
+    let client = bare_worker_contract::BareWorkerClient::new(env, &contract_id);
+    (contract_id, client)
+}