@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.20

package/contracts/workers/executor-helper/src/tests/setup.rs

@@ -0,0 +1,366 @@
+use endpoint_v2::Origin;
+use executor::NativeDropParams;
+use soroban_sdk::testutils::Address as _;
+use soroban_sdk::{
+    contract, contractimpl, contracttype,
+    testutils::{MockAuth, MockAuthInvoke},
+    token::StellarAssetClient,
+    Address, Bytes, BytesN, Env, IntoVal, Symbol, Vec,
+};
+
+use crate::{ComposeParams, ExecutionParams, ExecutorHelper, ExecutorHelperClient};
+
+// =============================================================================
+// Mock Endpoint (provides native_token)
+// =============================================================================
+
+#[contract]
+pub struct MockEndpoint;
+
+#[contractimpl]
+impl MockEndpoint {
+    pub fn __constructor(env: &Env, native_token: &Address) {
+        env.storage().instance().set(&Symbol::new(env, "native_token"), native_token);
+    }
+
+    pub fn native_token(env: &Env) -> Address {
+        env.storage().instance().get(&Symbol::new(env, "native_token")).unwrap()
+    }
+}
+
+// =============================================================================
+// Mock Receiver (implements lz_receive)
+// =============================================================================
+
+#[contract]
+pub struct MockReceiver;
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct LzReceiveRecord {
+    pub executor: Address,
+    pub origin: Origin,
+    pub guid: BytesN<32>,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub value: i128,
+}
+
+#[contractimpl]
+impl MockReceiver {
+    pub fn __constructor(_env: &Env) {}
+
+    pub fn lz_receive(
+        env: &Env,
+        executor: &Address,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        extra_data: &Bytes,
+        value: i128,
+    ) {
+        executor.require_auth();
+        let record = LzReceiveRecord {
+            executor: executor.clone(),
+            origin: origin.clone(),
+            guid: guid.clone(),
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            value,
+        };
+        env.storage().instance().set(&Symbol::new(env, "lz_receive"), &record);
+    }
+
+    pub fn get_lz_receive(env: &Env) -> Option<LzReceiveRecord> {
+        env.storage().instance().get(&Symbol::new(env, "lz_receive"))
+    }
+}
+
+// =============================================================================
+// Mock Composer (implements lz_compose)
+// =============================================================================
+
+#[contract]
+pub struct MockComposer;
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct LzComposeRecord {
+    pub executor: Address,
+    pub from: Address,
+    pub guid: BytesN<32>,
+    pub index: u32,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub value: i128,
+}
+
+#[contractimpl]
+impl MockComposer {
+    pub fn __constructor(_env: &Env) {}
+
+    pub fn lz_compose(
+        env: &Env,
+        executor: &Address,
+        from: &Address,
+        guid: &BytesN<32>,
+        index: u32,
+        message: &Bytes,
+        extra_data: &Bytes,
+        value: i128,
+    ) {
+        executor.require_auth();
+        let record = LzComposeRecord {
+            executor: executor.clone(),
+            from: from.clone(),
+            guid: guid.clone(),
+            index,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            value,
+        };
+        env.storage().instance().set(&Symbol::new(env, "lz_compose"), &record);
+    }
+
+    pub fn get_lz_compose(env: &Env) -> Option<LzComposeRecord> {
+        env.storage().instance().get(&Symbol::new(env, "lz_compose"))
+    }
+}
+
+// =============================================================================
+// Mock Executor (provides endpoint() and native_drop())
+// =============================================================================
+
+#[contract]
+pub struct MockExecutor;
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct NativeDropRecord {
+    pub admin: Address,
+    pub origin: Origin,
+    pub dst_eid: u32,
+    pub oapp: Address,
+    pub params: Vec<NativeDropParams>,
+}
+
+#[contractimpl]
+impl MockExecutor {
+    pub fn __constructor(env: &Env, endpoint: &Address) {
+        env.storage().instance().set(&Symbol::new(env, "endpoint"), endpoint);
+    }
+
+    pub fn endpoint(env: &Env) -> Address {
+        env.storage().instance().get(&Symbol::new(env, "endpoint")).unwrap()
+    }
+
+    pub fn native_drop(
+        env: &Env,
+        admin: &Address,
+        origin: &Origin,
+        dst_eid: u32,
+        oapp: &Address,
+        params: &Vec<NativeDropParams>,
+    ) {
+        admin.require_auth();
+        let record = NativeDropRecord {
+            admin: admin.clone(),
+            origin: origin.clone(),
+            dst_eid,
+            oapp: oapp.clone(),
+            params: params.clone(),
+        };
+        env.storage().instance().set(&Symbol::new(env, "native_drop"), &record);
+    }
+
+    pub fn get_native_drop(env: &Env) -> Option<NativeDropRecord> {
+        env.storage().instance().get(&Symbol::new(env, "native_drop"))
+    }
+}
+
+// =============================================================================
+// Test Setup
+// =============================================================================
+
+pub struct TestSetup<'a> {
+    pub env: Env,
+    pub executor_helper_client: ExecutorHelperClient<'a>,
+    pub executor: Address,
+    pub receiver: Address,
+    pub composer: Address,
+    pub native_token: Address,
+    pub native_token_admin: Address,
+    pub native_token_admin_client: StellarAssetClient<'a>,
+    pub admin: Address,
+}
+
+impl<'a> TestSetup<'a> {
+    pub fn new() -> Self {
+        let env = Env::default();
+
+        // Native token
+        let native_token_admin = Address::generate(&env);
+        let native_token_sac = env.register_stellar_asset_contract_v2(native_token_admin.clone());
+        let native_token = native_token_sac.address();
+        let native_token_admin_client = StellarAssetClient::new(&env, &native_token);
+
+        // Mock endpoint (with native_token)
+        let endpoint = env.register(MockEndpoint, (&native_token,));
+
+        // Mock executor (with endpoint reference)
+        let executor = env.register(MockExecutor, (&endpoint,));
+
+        // Mock receiver
+        let receiver = env.register(MockReceiver, ());
+
+        // Mock composer
+        let composer = env.register(MockComposer, ());
+
+        // Admin address (value payer)
+        let admin = Address::generate(&env);
+
+        // Register ExecutorHelper contract
+        let contract_id = env.register(ExecutorHelper, ());
+        let client = ExecutorHelperClient::new(&env, &contract_id);
+
+        Self {
+            env,
+            executor_helper_client: client,
+            executor,
+            receiver,
+            composer,
+            native_token,
+            native_token_admin,
+            native_token_admin_client,
+            admin,
+        }
+    }
+
+    pub fn mint_native(&self, to: &Address, amount: i128) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.native_token_admin,
+            invoke: &MockAuthInvoke {
+                contract: &self.native_token,
+                fn_name: "mint",
+                args: (to, amount).into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.native_token_admin_client.mint(to, &amount);
+    }
+
+    pub fn balance_native(&self, addr: &Address) -> i128 {
+        soroban_sdk::token::TokenClient::new(&self.env, &self.native_token).balance(addr)
+    }
+
+    pub fn mock_lz_receive_auth(&self, executor: &Address, params: &ExecutionParams) {
+        self.env.mock_auths(&[MockAuth {
+            address: executor,
+            invoke: &MockAuthInvoke {
+                contract: &params.receiver,
+                fn_name: "lz_receive",
+                args: (executor, &params.origin, &params.guid, &params.message, &params.extra_data, &params.value)
+                    .into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+    }
+
+    pub fn mock_lz_compose_auth(&self, executor: &Address, params: &ComposeParams) {
+        self.env.mock_auths(&[MockAuth {
+            address: executor,
+            invoke: &MockAuthInvoke {
+                contract: &params.to,
+                fn_name: "lz_compose",
+                args: (
+                    executor,
+                    &params.from,
+                    &params.guid,
+                    &params.index,
+                    &params.message,
+                    &params.extra_data,
+                    &params.value,
+                )
+                    .into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+    }
+
+    pub fn mock_native_drop_auth(
+        &self,
+        executor: &Address,
+        admin: &Address,
+        origin: &Origin,
+        dst_eid: u32,
+        oapp: &Address,
+        params: &Vec<NativeDropParams>,
+    ) {
+        self.env.mock_auths(&[MockAuth {
+            address: admin,
+            invoke: &MockAuthInvoke {
+                contract: executor,
+                fn_name: "native_drop",
+                args: (admin, origin, &dst_eid, oapp, params).into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+    }
+
+    pub fn default_origin(&self) -> Origin {
+        Origin { src_eid: 1, sender: BytesN::from_array(&self.env, &[1u8; 32]), nonce: 1 }
+    }
+
+    pub fn default_guid(&self) -> BytesN<32> {
+        BytesN::from_array(&self.env, &[2u8; 32])
+    }
+
+    pub fn default_message(&self) -> Bytes {
+        Bytes::from_slice(&self.env, &[1, 2, 3, 4])
+    }
+
+    pub fn default_extra_data(&self) -> Bytes {
+        Bytes::from_slice(&self.env, &[5, 6, 7, 8])
+    }
+
+    pub fn default_execution_params(&self) -> ExecutionParams {
+        ExecutionParams {
+            receiver: self.receiver.clone(),
+            origin: self.default_origin(),
+            guid: self.default_guid(),
+            message: self.default_message(),
+            extra_data: self.default_extra_data(),
+            value: 0,
+            gas_limit: 100,
+        }
+    }
+
+    pub fn default_compose_params(&self) -> ComposeParams {
+        let from = Address::generate(&self.env);
+        ComposeParams {
+            from,
+            to: self.composer.clone(),
+            guid: self.default_guid(),
+            index: 4,
+            message: self.default_message(),
+            extra_data: self.default_extra_data(),
+            value: 0,
+            gas_limit: 100,
+        }
+    }
+
+    /// Returns the MockReceiverClient to access mock receiver methods
+    pub fn receiver_client(&self) -> MockReceiverClient<'_> {
+        MockReceiverClient::new(&self.env, &self.receiver)
+    }
+
+    /// Returns the MockComposerClient to access mock composer methods
+    pub fn composer_client(&self) -> MockComposerClient<'_> {
+        MockComposerClient::new(&self.env, &self.composer)
+    }
+
+    /// Returns the MockExecutorClient to access mock executor methods
+    pub fn executor_client(&self) -> MockExecutorClient<'_> {
+        MockExecutorClient::new(&self.env, &self.executor)
+    }
+}

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

@@ -0,0 +1,14 @@
+[package]
+name = "fee-lib-interfaces"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+crate-type = ["rlib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+

package/contracts/workers/{worker/src/interfaces/mod.rs → fee-lib-interfaces/src/lib.rs}

@@ -1,6 +1,7 @@
-pub mod dvn_fee_lib;
-pub mod executor_fee_lib;
-pub mod price_feed;
+#![no_std]
+mod dvn_fee_lib;
+mod executor_fee_lib;
+mod price_feed;
 
 pub use dvn_fee_lib::*;
 pub use executor_fee_lib::*;

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

@@ -12,9 +12,10 @@ doctest = false
 [dependencies]
 soroban-sdk = { workspace = true }
 utils = { workspace = true }
-worker = { workspace = true }
+fee-lib-interfaces = { workspace = true }
 common-macros = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }
 

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

@@ -1,6 +1,6 @@
 use soroban_sdk::{contractevent, Address};
 
-use worker::Price;
+use fee_lib_interfaces::Price;
 
 use crate::types::ArbitrumPriceExt;
 

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

@@ -8,3 +8,6 @@ pub mod price_feed;
 pub mod types;
 
 pub use price_feed::{LzPriceFeed, LzPriceFeedClient};
+
+#[cfg(test)]
+mod tests;

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

@@ -1,7 +1,7 @@
 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 worker::{FeeEstimate, ILayerZeroPriceFeed, Price};
 
 use crate::{
     errors::PriceFeedError,
@@ -102,9 +102,7 @@ impl LzPriceFeed {
     /// Set the fee model type for destination EIDs (owner only)
     #[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);
-        }
+        params.iter().for_each(|param| PriceFeedStorage::set_eid_to_model_type(env, param.dst_eid, &param.model_type));
     }
 
     // ========================================================================
@@ -115,9 +113,7 @@ impl LzPriceFeed {
     pub fn set_price(env: &Env, price_updater: &Address, prices: &Vec<UpdatePrice>) {
         Self::require_price_updater(env, price_updater);
 
-        for update in prices.iter() {
-            Self::set_price_internal(env, update.eid, &update.price);
-        }
+        prices.iter().for_each(|update| Self::set_price_internal(env, update.eid, &update.price));
     }
 
     /// Set price for Arbitrum with extension (price updater or owner)
@@ -134,7 +130,7 @@ impl LzPriceFeed {
 
     /// Set the native token price in USD (price updater or owner).
     ///
-    /// Kept as a standalone contract function (not part of the canonical `worker::ILayerZeroPriceFeed` interface).
+    /// Kept as a standalone contract function (not part of the canonical `fee_lib_interfaces::ILayerZeroPriceFeed` interface).
     pub fn set_native_token_price_usd(env: &Env, price_updater: &Address, native_token_price_usd: u128) {
         Self::require_price_updater(env, price_updater);
         PriceFeedStorage::set_native_price_usd(env, &native_token_price_usd);
@@ -275,10 +271,8 @@ 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) {
-        // No migration logic needed for initial upgrade capability
-    }
+    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {}
 }

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

@@ -1,6 +1,6 @@
 use common_macros::storage;
+use fee_lib_interfaces::Price;
 use soroban_sdk::Address;
-use worker::Price;
 
 use crate::types::{ArbitrumPriceExt, ModelType};
 

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

@@ -0,0 +1,2 @@
+mod price_feed;
+mod setup;