@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.18

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

@@ -1,9 +1,12 @@
-use crate::tests::setup::{TestSetup, DEFAULT_MULTIPLIER_BPS, VID};
-use crate::{dvn::LzDVN, errors::DvnError, storage::DvnStorage};
+use crate::{
+    dvn::LzDVN,
+    tests::setup::{TestSetup, DEFAULT_MULTIPLIER_BPS, VID},
+};
 use soroban_sdk::{
     testutils::{Address as _, AuthorizedFunction, BytesN as _},
     vec, Address, BytesN, Env, IntoVal, Symbol, Vec,
 };
+use utils::errors::MultisigError;
 
 fn random_signer(env: &Env) -> BytesN<20> {
     BytesN::random(env)
@@ -66,7 +69,7 @@ fn test_set_threshold_zero_fails() {
     let setup = TestSetup::new(1);
 
     let res = setup.multisig_client.try_set_threshold(&0);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::ZeroThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::ZeroThreshold.into());
 }
 
 #[test]
@@ -74,7 +77,7 @@ fn test_set_threshold_above_signers_fails() {
     let setup = TestSetup::new(2);
 
     let res = setup.multisig_client.try_set_threshold(&3);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
 }
 
 #[test]
@@ -82,15 +85,15 @@ fn test_set_threshold_with_no_signers_fails() {
     let setup = TestSetup::new(1);
 
     setup.env.as_contract(&setup.contract_id, || {
-        DvnStorage::remove_signers(&setup.env);
+        utils::multisig::MultisigStorage::remove_signers(&setup.env);
     });
 
     let res = setup.multisig_client.try_set_threshold(&1);
-    assert_eq!(res.err().unwrap().ok().unwrap(), DvnError::TotalSignersLessThanThreshold.into());
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::TotalSignersLessThanThreshold.into());
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #14)")] // DvnError::ZeroThreshold
+#[should_panic(expected = "Error(Contract, #1067)")] // ZeroThreshold
 fn test_constructor_threshold_zero_panics() {
     let env = Env::default();
     env.mock_all_auths();
@@ -99,7 +102,7 @@ fn test_constructor_threshold_zero_panics() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #12)")] // DvnError::TotalSignersLessThanThreshold
+#[should_panic(expected = "Error(Contract, #1065)")] // 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

@@ -1,9 +1,8 @@
 extern crate std;
 
-use crate::storage::DvnStorage;
-use crate::tests::key_pair::KeyPair;
-use crate::tests::setup::TestSetup;
+use crate::tests::{key_pair::KeyPair, setup::TestSetup};
 use soroban_sdk::{vec, Bytes, BytesN, Vec};
+use utils::errors::MultisigError;
 
 fn hash(env: &soroban_sdk::Env, label: &[u8]) -> BytesN<32> {
     env.crypto().keccak256(&Bytes::from_slice(env, label)).to_bytes()
@@ -59,7 +58,6 @@ fn test_verify_signatures_raw_v_path() {
 }
 
 #[test]
-#[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");
@@ -67,22 +65,22 @@ fn test_verify_signatures_with_wrong_signer() {
     let signature = wrong_key_pair.sign(&digest.to_array());
     let signatures: Vec<BytesN<65>> = vec![&setup.env, BytesN::from_array(&setup.env, &signature)];
 
-    setup.multisig_client.verify_signatures(&digest, &signatures);
+    let res = setup.multisig_client.try_verify_signatures(&digest, &signatures);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignerNotFound.into());
 }
 
 #[test]
-#[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");
 
     let signatures: Vec<BytesN<65>> = vec![&setup.env, sign(&setup, 0, &digest)];
 
-    setup.multisig_client.verify_signatures(&digest, &signatures);
+    let res = setup.multisig_client.try_verify_signatures(&digest, &signatures);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::SignatureError.into());
 }
 
 #[test]
-#[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");
@@ -90,20 +88,21 @@ fn test_verify_signatures_duplicate_signer() {
     let sig1 = sign(&setup, 0, &digest);
     let signatures: Vec<BytesN<65>> = vec![&setup.env, sig1.clone(), sig1];
 
-    setup.multisig_client.verify_signatures(&digest, &signatures);
+    let res = setup.multisig_client.try_verify_signatures(&digest, &signatures);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::UnsortedSigners.into());
 }
 
 #[test]
-#[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
     setup.env.as_contract(&setup.contract_id, || {
-        DvnStorage::set_threshold(&setup.env, &0);
+        utils::multisig::MultisigStorage::set_threshold(&setup.env, &0);
     });
     let digest = hash(&setup.env, b"threshold_zero");
 
     let signatures: Vec<BytesN<65>> = vec![&setup.env, sign(&setup, 0, &digest)];
 
-    setup.multisig_client.verify_signatures(&digest, &signatures);
+    let res = setup.multisig_client.try_verify_signatures(&digest, &signatures);
+    assert_eq!(res.err().unwrap().ok().unwrap(), MultisigError::ZeroThreshold.into());
 }

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

@@ -2,9 +2,9 @@
 
 extern crate std;
 
-use crate::tests::key_pair::KeyPair;
-use crate::{dvn::LzDVN, interfaces::MultiSigClient};
+use crate::{dvn::LzDVN, tests::key_pair::KeyPair};
 use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, vec, Address, BytesN, Env, Vec};
+use utils::multisig::MultisigClient;
 use std::vec::Vec as StdVec;
 
 pub const VID: u32 = 1;
@@ -13,7 +13,7 @@ pub const DEFAULT_MULTIPLIER_BPS: u32 = 10000;
 pub struct TestSetup<'a> {
     pub env: Env,
     pub contract_id: Address,
-    pub multisig_client: MultiSigClient<'a>,
+    pub multisig_client: MultisigClient<'a>,
     pub key_pairs: StdVec<KeyPair>,
     pub admins: Vec<Address>,
 }
@@ -58,7 +58,7 @@ impl<'a> TestSetup<'a> {
             ),
         );
 
-        let multisig_client = MultiSigClient::new(&env, &contract_id);
+        let multisig_client = MultisigClient::new(&env, &contract_id);
 
         Self { env, contract_id, multisig_client, key_pairs, admins }
     }
@@ -102,7 +102,7 @@ impl<'a> TestSetup<'a> {
             ),
         );
 
-        let multisig_client = MultiSigClient::new(&env, &contract_id);
+        let multisig_client = MultisigClient::new(&env, &contract_id);
 
         Self { env, contract_id, multisig_client, key_pairs, admins }
     }

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

@@ -10,7 +10,7 @@ library = []
 testutils = []
 
 [lib]
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]

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

@@ -1,6 +1,6 @@
 use crate::errors::DvnFeeLibError;
-use common_macros::{contract_impl, ownable, ttl_configurable, upgradeable};
-use soroban_sdk::{assert_with_error, contract, Address, Env};
+use common_macros::{contract_impl, lz_contract};
+use soroban_sdk::{assert_with_error, Address, Env};
 use utils::upgradeable::UpgradeableInternal;
 use worker::{DvnFeeParams, IDvnFeeLib, LayerZeroPriceFeedClient};
 
@@ -28,10 +28,7 @@ pub(crate) const NATIVE_DECIMALS_RATE: u128 = 10_000_000;
 /// Provides fee calculation logic based on quorum size, destination gas costs,
 /// and current gas prices from the price feed. Handles fee multipliers and
 /// floor margins.
-#[contract]
-#[ownable]
-#[ttl_configurable]
-#[upgradeable]
+#[lz_contract(upgradeable)]
 pub struct DvnFeeLib;
 
 #[contract_impl]

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

@@ -1,10 +1,11 @@
 use super::*;
-
+use endpoint_v2::LayerZeroEndpointV2Client;
 use soroban_sdk::{
     address_payload::AddressPayload,
     auth::{Context, CustomAccountInterface},
-    contractimpl, contracttype,
+    contracttype,
     crypto::Hash,
+    Symbol, TryFromVal, Val,
 };
 
 // ============================================================================
@@ -26,7 +27,7 @@ pub struct ExecutorSignature {
 // Custom Account Interface Implementation
 // ============================================================================
 
-#[contractimpl]
+#[contract_impl]
 impl CustomAccountInterface for LzExecutor {
     type Signature = ExecutorSignature;
     type Error = ExecutorError;
@@ -35,7 +36,6 @@ impl CustomAccountInterface for LzExecutor {
     ///
     /// The public key must correspond to a registered admin and must have signed the signature_payload.
     /// Uses Ed25519 signature verification.
-    /// Only whitelisted function calls are authorized.
     fn __check_auth(
         env: Env,
         signature_payload: Hash<32>,
@@ -70,24 +70,88 @@ impl LzExecutor {
         Ok(())
     }
 
-    /// Validates that the first auth context is a whitelisted (contract, function) pair.
-    /// Sub-invocations are trusted since they're controlled by the whitelisted contract.
+    /// Validates auth contexts according to executor rules.
+    ///
+    /// # Design
+    ///
+    /// For `lz_receive`: OApps call `verify_and_clear_payload` (see `oapp_receiver.rs`)
+    /// which requires executor auth and optionally transfers native token from executor to OApp.
+    ///
+    /// For `lz_compose`: Composers follow the same pattern - require executor auth and
+    /// optionally transfer native token from executor to composer.
+    ///
+    /// Both create 1-2 auth contexts depending on whether value == 0:
+    /// - Context 1: `lz_receive`/`lz_compose` on the OApp/Composer (always present)
+    /// - Context 2: `transfer` on native token (only if value != 0)
+    ///
+    /// For `lz_receive_alert`/`lz_compose_alert`: These are called directly on the endpoint
+    /// to record failed executions. Only 1 context on the endpoint is expected.
     fn validate_auth_contexts(env: &Env, contexts: &Vec<Context>) -> Result<(), ExecutorError> {
-        let first_context = contexts.first().ok_or(ExecutorError::UnauthorizedContext)?;
-
-        match first_context {
-            Context::Contract(contract_context) => {
-                // Check if (contract, fn_name) pair is whitelisted
-                if !Self::is_whitelisted_fn(env, &contract_context.contract, &contract_context.fn_name) {
-                    return Err(ExecutorError::UnauthorizedContext);
-                }
+        // Early bounds check: max 2 contexts expected
+        if contexts.len() > 2 {
+            return Err(ExecutorError::UnauthorizedContext);
+        }
+
+        let first_ctx = contexts.first().ok_or(ExecutorError::UnauthorizedContext)?;
+        let Context::Contract(first_ctx) = first_ctx else {
+            return Err(ExecutorError::UnauthorizedContext);
+        };
+
+        let first_fn_name = &first_ctx.fn_name;
+
+        // Alert path: lz_receive_alert or lz_compose_alert (lazy Symbol creation)
+        if *first_fn_name == Symbol::new(env, "lz_receive_alert")
+            || *first_fn_name == Symbol::new(env, "lz_compose_alert")
+        {
+            // Require exactly 1 context and the contract must be the endpoint
+            if contexts.len() != 1 || first_ctx.contract != Self::endpoint(env) {
+                return Err(ExecutorError::UnauthorizedContext);
             }
-            // Contract creation is not allowed
-            Context::CreateContractHostFn(_) | Context::CreateContractWithCtorHostFn(_) => {
+            return Ok(());
+        }
+
+        // Execute path: lz_receive or lz_compose
+        if *first_fn_name != Symbol::new(env, "lz_receive") && *first_fn_name != Symbol::new(env, "lz_compose") {
+            return Err(ExecutorError::UnauthorizedContext);
+        }
+
+        let value = Self::extract_i128(env, first_ctx.args.last())?;
+        if value == 0 {
+            // If value is 0, there should be exactly 1 context
+            if contexts.len() != 1 {
                 return Err(ExecutorError::UnauthorizedContext);
             }
+            return Ok(());
+        }
+
+        // value != 0: validate transfer context (only if there are 2 contexts)
+        if contexts.len() != 2 {
+            return Err(ExecutorError::UnauthorizedContext);
+        }
+
+        // Second context must be the transfer context
+        let Context::Contract(second_ctx) = contexts.get(1).unwrap() else {
+            return Err(ExecutorError::UnauthorizedContext);
+        };
+
+        let native_token = LayerZeroEndpointV2Client::new(env, &Self::endpoint(env)).native_token();
+        let transfer_amount = Self::extract_i128(env, second_ctx.args.get(2))?;
+
+        // Validate transfer context: must be transfer with matching value and native token contract
+        if second_ctx.fn_name != Symbol::new(env, "transfer")
+            || second_ctx.contract != native_token
+            || transfer_amount != value
+        {
+            return Err(ExecutorError::UnauthorizedContext);
         }
 
         Ok(())
     }
+
+    /// Extracts an i128 value from an optional Val.
+    #[inline]
+    fn extract_i128(env: &Env, val: Option<Val>) -> Result<i128, ExecutorError> {
+        let val = val.ok_or(ExecutorError::UnauthorizedContext)?;
+        i128::try_from_val(env, &val).map_err(|_| ExecutorError::UnauthorizedContext)
+    }
 }

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

@@ -5,29 +5,25 @@ use crate::{
     storage::ExecutorStorage,
     NativeDropParams,
 };
-use common_macros::{contract_impl, only_owner, ownable, ttl_configurable, upgradeable};
+use common_macros::{contract_impl, lz_contract};
 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::upgradeable::UpgradeableInternal;
+use soroban_sdk::{token::TokenClient, vec, Address, Bytes, BytesN, Env, Vec};
+use utils::{option_ext::OptionExt, 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,
 };
 
 /// LayerZero Executor contract for cross-chain message execution.
-#[contract]
-#[ttl_configurable]
-#[upgradeable]
-#[ownable]
+#[lz_contract(upgradeable)]
 pub struct LzExecutor;
 
 #[contract_impl]
 impl LzExecutor {
     /// Initializes the executor contract.
     ///
-    /// Sets up ownership, worker configuration, endpoint address, and whitelisted functions.
+    /// Sets up ownership, worker configuration, and endpoint address.
     ///
     /// # Arguments
     /// * `endpoint` - LayerZero Endpoint V2 contract address
@@ -36,7 +32,6 @@ impl LzExecutor {
     /// * `message_libs` - Supported message library addresses (e.g., ULN302)
     /// * `price_feed` - Price feed contract address for fee calculations
     /// * `default_multiplier_bps` - Default fee multiplier in basis points (10000 = 1x)
-    /// * `whitelist` - Initial whitelisted (contract, function) pairs for authorization
     /// * `worker_fee_lib` - Worker fee library contract address
     /// * `deposit_address` - Address to receive fee payments
     pub fn __constructor(
@@ -47,7 +42,6 @@ impl LzExecutor {
         message_libs: &Vec<Address>,
         price_feed: &Address,
         default_multiplier_bps: u32,
-        whitelist: &Vec<(Address, Symbol)>,
         worker_fee_lib: &Address,
         deposit_address: &Address,
     ) {
@@ -62,26 +56,6 @@ impl LzExecutor {
             deposit_address,
         );
         ExecutorStorage::set_endpoint(env, endpoint);
-
-        // Set initial whitelisted functions
-        for (contract, fn_name) in whitelist.iter() {
-            ExecutorStorage::set_whitelisted_fn(env, &contract, &fn_name, &true);
-        }
-    }
-
-    /// Sets whether a (contract, function) pair is whitelisted.
-    /// When `allowed` is false, the entry is removed from storage to save space.
-    ///
-    /// Only the contract owner can call this function.
-    #[only_owner]
-    pub fn set_whitelisted_fn(env: &Env, contract: &Address, fn_name: &Symbol, allowed: bool) {
-        let value = if allowed { Some(true) } else { None };
-        ExecutorStorage::set_or_remove_whitelisted_fn(env, contract, fn_name, &value);
-    }
-
-    /// Returns whether a (contract, function) pair is whitelisted.
-    pub fn is_whitelisted_fn(env: &Env, contract: &Address, fn_name: &Symbol) -> bool {
-        ExecutorStorage::has_whitelisted_fn(env, contract, fn_name)
     }
 
     /// Withdraws a token from the contract to a specified address.

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

@@ -1,12 +1,12 @@
 use common_macros::storage;
-use soroban_sdk::{Address, Symbol};
+use soroban_sdk::Address;
 
 use crate::DstConfig;
 
 /// Storage keys for the Executor contract.
 ///
 /// Manages persistent storage for destination configurations and instance storage
-/// for the endpoint address and whitelisted functions.
+/// for the endpoint address.
 #[storage]
 pub enum ExecutorStorage {
     /// Destination chain configuration indexed by endpoint ID.
@@ -21,11 +21,4 @@ pub enum ExecutorStorage {
     /// Used for receive-flow operations to interact with the endpoint.
     #[instance(Address)]
     Endpoint,
-
-    /// Whitelisted function for a specific contract.
-    ///
-    /// Only whitelisted (contract, function) pairs can trigger Executor authorization.
-    /// This allows fine-grained control over which contracts can call which functions.
-    #[instance(bool)]
-    WhitelistedFn { contract: Address, fn_name: Symbol },
 }

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

@@ -6,7 +6,7 @@ license.workspace = true
 publish = false
 
 [lib]
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]

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

@@ -1,6 +1,6 @@
 use crate::{errors::ExecutorFeeLibError, executor_option};
-use common_macros::{contract_impl, ownable, ttl_configurable, upgradeable};
-use soroban_sdk::{assert_with_error, contract, Address, Bytes, Env};
+use common_macros::{contract_impl, lz_contract};
+use soroban_sdk::{assert_with_error, Address, Bytes, Env};
 use utils::upgradeable::UpgradeableInternal;
 use worker::{FeeParams, IExecutorFeeLib, LayerZeroPriceFeedClient};
 
@@ -25,10 +25,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.
-#[contract]
-#[ownable]
-#[ttl_configurable]
-#[upgradeable]
+#[lz_contract(upgradeable)]
 pub struct ExecutorFeeLib;
 
 #[contract_impl]

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

@@ -6,7 +6,7 @@ license.workspace = true
 publish = false
 
 [lib]
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]

package/contracts/workers/executor-helper/src/executor_helper.rs

@@ -1,11 +1,11 @@
 //! ABA-safe entry point for cross-chain message execution on Stellar.
 //! Prevents reentry into the Executor during OApp Atomic Batch Actions.
 
+use common_macros::contract_impl;
 use endpoint_v2::{
     LayerZeroComposerClient, LayerZeroEndpointV2Client, LayerZeroReceiverClient, MessagingComposerClient, Origin,
 };
 use executor::{ExecutorClient, NativeDropParams};
-use common_macros::contract_impl;
 use soroban_sdk::{contract, contracttype, token::TokenClient, Address, Bytes, BytesN, Env, Vec};
 
 /// Parameters for `lz_receive` execution.
@@ -40,28 +40,43 @@ pub struct ExecutorHelper;
 
 #[contract_impl]
 impl ExecutorHelper {
-    /// Executes `lz_receive` on the target OApp; falls back to `lz_receive_alert` on failure.
+    /// Executes `lz_receive` on the target OApp
     pub fn execute(env: &Env, executor: &Address, params: &ExecutionParams, value_payer: &Address) {
-        if params.value > 0 {
-            value_payer.require_auth();
+        if params.value != 0 {
+            transfer_value(env, value_payer, executor, params.value);
         }
-        Self::execute_internal(env, executor, params, value_payer);
+        LayerZeroReceiverClient::new(env, &params.receiver).lz_receive(
+            executor,
+            &params.origin,
+            &params.guid,
+            &params.message,
+            &params.extra_data,
+            &params.value,
+        );
     }
 
-    /// Executes `lz_compose` on the target composer; falls back to `lz_compose_alert` on failure.
-    pub fn compose(env: &Env, executor: &Address, params: &ComposeParams, value_payer: &Address) {
-        executor.require_auth();
-
-        let endpoint = if params.value > 0 {
-            let ep = ExecutorClient::new(env, executor).endpoint();
-            value_payer.require_auth();
-            transfer_value(env, &ep, value_payer, executor, params.value);
-            Some(ep)
-        } else {
-            None
-        };
+    /// Records a failed `lz_receive` execution for off-chain processing.
+    pub fn lz_receive_alert(env: &Env, executor: &Address, params: &ExecutionParams, reason: &Bytes) {
+        let endpoint = ExecutorClient::new(env, executor).endpoint();
+        LayerZeroEndpointV2Client::new(env, &endpoint).lz_receive_alert(
+            executor,
+            &params.origin,
+            &params.receiver,
+            &params.guid,
+            &params.gas_limit,
+            &params.value,
+            &params.message,
+            &params.extra_data,
+            reason,
+        );
+    }
 
-        let result = LayerZeroComposerClient::new(env, &params.to).try_lz_compose(
+    /// Executes `lz_compose` on the target composer
+    pub fn compose(env: &Env, executor: &Address, params: &ComposeParams, value_payer: &Address) {
+        if params.value != 0 {
+            transfer_value(env, value_payer, executor, params.value);
+        }
+        LayerZeroComposerClient::new(env, &params.to).lz_compose(
             executor,
             &params.from,
             &params.guid,
@@ -70,22 +85,23 @@ impl ExecutorHelper {
             &params.extra_data,
             &params.value,
         );
+    }
 
-        if result.is_err() {
-            let ep = endpoint.unwrap_or_else(|| ExecutorClient::new(env, executor).endpoint());
-            MessagingComposerClient::new(env, &ep).lz_compose_alert(
-                executor,
-                &params.from,
-                &params.to,
-                &params.guid,
-                &params.index,
-                &params.gas_limit,
-                &params.value,
-                &params.message,
-                &params.extra_data,
-                &Bytes::new(env),
-            );
-        }
+    /// Records a failed `lz_compose` execution for off-chain processing.
+    pub fn lz_compose_alert(env: &Env, executor: &Address, params: &ComposeParams, reason: &Bytes) {
+        let endpoint = ExecutorClient::new(env, executor).endpoint();
+        MessagingComposerClient::new(env, &endpoint).lz_compose_alert(
+            executor,
+            &params.from,
+            &params.to,
+            &params.guid,
+            &params.index,
+            &params.gas_limit,
+            &params.value,
+            &params.message,
+            &params.extra_data,
+            reason,
+        );
     }
 
     /// Delegates `native_drop` to the executor contract.
@@ -98,7 +114,6 @@ impl ExecutorHelper {
         oapp: &Address,
         params: &Vec<NativeDropParams>,
     ) {
-        admin.require_auth();
         ExecutorClient::new(env, executor).native_drop(admin, origin, &dst_eid, oapp, params);
     }
 
@@ -114,48 +129,13 @@ impl ExecutorHelper {
         execute_params: &ExecutionParams,
     ) {
         Self::native_drop(env, executor, admin, origin, dst_eid, oapp, native_drop_params);
-        Self::execute_internal(env, executor, execute_params, admin); // admin already authed above
-    }
-
-    fn execute_internal(env: &Env, executor: &Address, params: &ExecutionParams, value_payer: &Address) {
-        executor.require_auth();
-
-        let endpoint = if params.value > 0 {
-            let ep = ExecutorClient::new(env, executor).endpoint();
-            transfer_value(env, &ep, value_payer, executor, params.value);
-            Some(ep)
-        } else {
-            None
-        };
-
-        let result = LayerZeroReceiverClient::new(env, &params.receiver).try_lz_receive(
-            executor,
-            &params.origin,
-            &params.guid,
-            &params.message,
-            &params.extra_data,
-            &params.value,
-        );
-
-        if result.is_err() {
-            let ep = endpoint.unwrap_or_else(|| ExecutorClient::new(env, executor).endpoint());
-            LayerZeroEndpointV2Client::new(env, &ep).lz_receive_alert(
-                executor,
-                &params.origin,
-                &params.receiver,
-                &params.guid,
-                &params.gas_limit,
-                &params.value,
-                &params.message,
-                &params.extra_data,
-                &Bytes::new(env),
-            );
-        }
+        Self::execute(env, executor, execute_params, admin);
     }
 }
 
 #[inline]
-fn transfer_value(env: &Env, endpoint: &Address, payer: &Address, executor: &Address, value: i128) {
-    let native_token = LayerZeroEndpointV2Client::new(env, endpoint).native_token();
+fn transfer_value(env: &Env, payer: &Address, executor: &Address, value: i128) {
+    let endpoint = ExecutorClient::new(env, executor).endpoint();
+    let native_token = LayerZeroEndpointV2Client::new(env, &endpoint).native_token();
     TokenClient::new(env, &native_token).transfer(payer, executor, &value);
 }

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

@@ -6,7 +6,7 @@ license.workspace = true
 publish = false
 
 [lib]
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [dependencies]