@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/oapps/oapp/src/oapp_receiver.rs

@@ -0,0 +1,72 @@
+use crate::{errors::OAppError, oapp_core::OAppCore};
+use endpoint_v2::{ILayerZeroReceiver, LayerZeroEndpointV2Client, Origin};
+use soroban_sdk::{assert_with_error, Address, Bytes, BytesN, Env};
+
+// =====================================================
+// OAppReceiver Traits
+// =====================================================
+
+pub trait OAppReceiver: ILayerZeroReceiver {
+    /// Indicates whether an address is an approved composeMsg sender to the Endpoint.
+    ///
+    /// Applications can optionally choose to implement separate composeMsg senders that are NOT the bridging layer.
+    /// The default sender IS the OAppReceiver implementer.
+    ///
+    /// # Arguments
+    /// * `origin` - The origin information containing the source endpoint and sender address
+    /// * `message` - The lzReceive payload
+    /// * `sender` - The sender address to check
+    ///
+    /// # Returns
+    /// True if the sender is a valid composeMsg sender, false otherwise
+    fn is_compose_msg_sender(env: &Env, origin: &Origin, message: &Bytes, sender: &Address) -> bool;
+}
+
+// =====================================================
+// Implement overrides for the OAppReceiver trait
+// =====================================================
+
+pub trait OAppReceiverOverrides: OAppCore {
+    fn __is_compose_msg_sender(env: &Env, _origin: &Origin, _message: &Bytes, sender: &Address) -> bool {
+        env.current_contract_address() == *sender
+    }
+
+    fn __allow_initialize_path(env: &Env, origin: &Origin) -> bool {
+        let peer = Self::peer(env, origin.src_eid);
+        peer.is_some_and(|peer| peer == origin.sender)
+    }
+
+    fn __next_nonce(_env: &Env, _src_eid: u32, _sender: &BytesN<32>) -> u64 {
+        0
+    }
+
+    fn __lz_receive(
+        env: &Env,
+        executor: &Address,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        extra_data: &Bytes,
+        value: i128,
+    );
+}
+
+// =====================================================
+// Helper functions
+// =====================================================
+
+pub fn verify_and_clear_payload<T: OAppCore>(
+    env: &Env,
+    executor: &Address,
+    origin: &Origin,
+    guid: &BytesN<32>,
+    message: &Bytes,
+) {
+    executor.require_auth();
+    assert_with_error!(env, Some(origin.sender.clone()) == T::peer(env, origin.src_eid), OAppError::OnlyPeer);
+
+    let contract_address = env.current_contract_address();
+    let endpoint_address = T::endpoint(env);
+    let endpoint = LayerZeroEndpointV2Client::new(env, &endpoint_address);
+    endpoint.clear(&contract_address, origin, &contract_address, guid, message);
+}

package/contracts/oapps/oapp/src/oapp_sender.rs

@@ -0,0 +1,66 @@
+use crate::{errors::OAppError, oapp_core::OAppCore};
+use endpoint_v2::{LayerZeroEndpointV2Client, MessagingFee, MessagingParams, MessagingReceipt};
+use soroban_sdk::{token::TokenClient, Address, Bytes, Env};
+use utils::option_ext::OptionExt;
+
+pub trait OAppSenderOverrides: OAppCore {
+    fn __quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
+        let endpoint = Self::endpoint(env);
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
+        let receiver = Self::peer(env, dst_eid).unwrap_or_panic(env, OAppError::NoPeer);
+        endpoint_client.quote(
+            &env.current_contract_address(),
+            &MessagingParams { dst_eid, receiver, message: message.clone(), options: options.clone(), pay_in_zro },
+        )
+    }
+
+    fn __lz_send(
+        env: &Env,
+        sender: &Address,
+        dst_eid: u32,
+        message: &Bytes,
+        options: &Bytes,
+        fee: &MessagingFee,
+        refund_address: &Address,
+    ) -> MessagingReceipt {
+        Self::__pay_native(env, sender, fee.native_fee);
+        if fee.zro_fee > 0 {
+            Self::__pay_zro(env, sender, fee.zro_fee);
+        }
+
+        let oapp = env.current_contract_address();
+        let endpoint = Self::endpoint(env);
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
+        let peer = Self::peer(env, dst_eid).unwrap_or_panic(env, OAppError::NoPeer);
+
+        endpoint_client.send(
+            &oapp,
+            &MessagingParams {
+                dst_eid,
+                receiver: peer,
+                message: message.clone(),
+                options: options.clone(),
+                pay_in_zro: fee.zro_fee > 0,
+            },
+            refund_address,
+        )
+    }
+
+    fn __pay_native(env: &Env, payer: &Address, native_fee: i128) {
+        let endpoint = Self::endpoint(env);
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
+        let native_token = endpoint_client.native_token();
+        let token_client = TokenClient::new(env, &native_token);
+
+        token_client.transfer(payer, &endpoint, &native_fee);
+    }
+
+    fn __pay_zro(env: &Env, payer: &Address, zro_fee: i128) {
+        let endpoint = Self::endpoint(env);
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
+        let zro_token = endpoint_client.zro().unwrap_or_panic(env, OAppError::ZROTokenUnavailable);
+        let token_client = TokenClient::new(env, &zro_token);
+
+        token_client.transfer(payer, &endpoint, &zro_fee);
+    }
+}

package/contracts/oapps/oapp/src/tests/mod.rs

@@ -0,0 +1,4 @@
+mod test_oapp_core;
+mod test_oapp_options_type3;
+mod test_oapp_receiver;
+mod test_oapp_sender;

package/contracts/oapps/oapp/src/tests/test_oapp_core.rs

@@ -0,0 +1,162 @@
+use crate::{self as oapp, oapp_core::PeerSet};
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, BytesN, Env, IntoVal,
+};
+use utils::ownable::Ownable;
+use utils::testing_utils::assert_event;
+
+#[contract]
+pub struct DummyEndpoint;
+
+#[contractimpl]
+impl DummyEndpoint {
+    pub fn set_delegate(_env: Env, _oapp: &Address, _delegate: &Option<Address>) {
+        // do nothing
+    }
+}
+
+#[oapp_macros::oapp_core]
+pub struct DummyOApp;
+
+#[contractimpl]
+impl DummyOApp {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
+        Self::__init_owner(env, owner);
+        Self::__oapp_initialize(env, endpoint, &None);
+    }
+}
+
+const REMOTE_EID: u32 = 100;
+const UNSET_EID: u32 = 999;
+
+struct TestSetup<'a> {
+    env: Env,
+    owner: Address,
+    endpoint: Address,
+    oapp_client: DummyOAppClient<'a>,
+}
+
+fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+
+    let owner = Address::generate(&env);
+    soroban_sdk::log!(&env, "owner: {}", owner);
+    let endpoint = env.register(DummyEndpoint, ());
+    soroban_sdk::log!(&env, "endpoint: {}", endpoint);
+    let oapp = env.register(DummyOApp, (&owner, &endpoint));
+    soroban_sdk::log!(&env, "oapp: {}", oapp);
+    let oapp_client = DummyOAppClient::new(&env, &oapp);
+    TestSetup { env, owner, endpoint, oapp_client }
+}
+
+#[test]
+fn test_set_peer() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+
+    let test_peer: BytesN<32> = BytesN::from_array(&env, &[33; 32]);
+    let test_peer_option = Some(test_peer.clone());
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "set_peer",
+            args: (&REMOTE_EID, &test_peer_option).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    oapp_client.set_peer(&REMOTE_EID, &test_peer_option);
+
+    // assert event
+    assert_event(&env, &oapp_client.address, PeerSet { eid: REMOTE_EID, peer: Some(test_peer.clone()) });
+
+    // Test getting peer for set eid
+    let retrieved_peer = oapp_client.peer(&REMOTE_EID);
+    assert_eq!(Some(test_peer), retrieved_peer);
+
+    // Test getting peer for unset eid
+    let retrieved_peer = oapp_client.peer(&UNSET_EID);
+    assert_eq!(None, retrieved_peer);
+}
+
+#[test]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_set_peer_unauthorized() {
+    let TestSetup { env, oapp_client, .. } = setup();
+
+    let test_peer: BytesN<32> = BytesN::from_array(&env, &[33; 32]);
+    oapp_client.set_peer(&REMOTE_EID, &Some(test_peer));
+}
+
+#[test]
+fn test_get_peer_success() {
+    let TestSetup { env, oapp_client, .. } = setup();
+    env.mock_all_auths();
+
+    let test_peer: BytesN<32> = BytesN::from_array(&env, &[1; 32]);
+    oapp_client.set_peer(&REMOTE_EID, &Some(test_peer.clone()));
+
+    let retrieved_peer = oapp_client.peer(&REMOTE_EID);
+    assert_eq!(Some(test_peer), retrieved_peer);
+}
+
+#[test]
+fn test_get_peer_returns_none_for_unset_eid() {
+    let TestSetup { oapp_client, .. } = setup();
+
+    let result = oapp_client.peer(&UNSET_EID);
+    assert_eq!(result, None);
+}
+
+#[test]
+fn test_update_peer() {
+    let TestSetup { env, oapp_client, .. } = setup();
+    env.mock_all_auths();
+
+    // Set initial peer
+    let initial_peer: BytesN<32> = BytesN::from_array(&env, &[1; 32]);
+    oapp_client.set_peer(&REMOTE_EID, &Some(initial_peer));
+
+    // Update to new peer
+    let updated_peer: BytesN<32> = BytesN::from_array(&env, &[2; 32]);
+    oapp_client.set_peer(&REMOTE_EID, &Some(updated_peer.clone()));
+
+    let retrieved_peer = oapp_client.peer(&REMOTE_EID);
+    assert_eq!(Some(updated_peer), retrieved_peer);
+}
+
+#[test]
+fn test_set_delegate() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+
+    let delegate = Address::generate(&env);
+    let delegate_option = Some(delegate.clone());
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "set_delegate",
+            args: (&delegate_option,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    oapp_client.set_delegate(&delegate_option);
+}
+
+#[test]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_set_delegate_unauthorized() {
+    let TestSetup { env, oapp_client, .. } = setup();
+
+    let delegate = Address::generate(&env);
+    oapp_client.set_delegate(&Some(delegate));
+}
+
+#[test]
+fn test_get_endpoint() {
+    let TestSetup { endpoint, oapp_client, .. } = setup();
+
+    let retrieved_endpoint = oapp_client.endpoint();
+    assert_eq!(endpoint, retrieved_endpoint);
+}

package/contracts/oapps/oapp/src/tests/test_oapp_options_type3.rs

@@ -0,0 +1,180 @@
+use crate as oapp;
+use crate::oapp_options_type3::EnforcedOptionParam;
+use crate::oapp_options_type3::EnforcedOptionSet;
+use crate::oapp_options_type3::OAppOptionsType3;
+use soroban_sdk::contractimpl;
+use soroban_sdk::{
+    contract,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    vec, Address, Bytes, Env, IntoVal,
+};
+use utils::ownable::Ownable;
+use utils::testing_utils::assert_event;
+
+const OPTION_TYPE_3: u32 = 3;
+const REMOTE_EID_1: u32 = 100;
+const REMOTE_EID_2: u32 = 200;
+const MSG_TYPE_SEND: u32 = 1;
+const MSG_TYPE_RECEIVE: u32 = 2;
+
+#[contract]
+#[common_macros::ownable]
+#[oapp_macros::oapp_options_type3]
+pub struct DummyOAppOptionsType3;
+
+#[contractimpl]
+impl DummyOAppOptionsType3 {
+    pub fn __constructor(env: &Env, owner: &Address) {
+        Self::__init_owner(env, owner);
+    }
+}
+
+struct TestSetup<'a> {
+    env: Env,
+    owner: Address,
+    oapp_client: DummyOAppOptionsType3Client<'a>,
+}
+
+fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+
+    let owner = Address::generate(&env);
+    let oapp = env.register(DummyOAppOptionsType3, (&owner,));
+    let oapp_client = DummyOAppOptionsType3Client::new(&env, &oapp);
+
+    TestSetup { env, owner, oapp_client }
+}
+
+fn create_valid_options(env: &Env, data: &[u8]) -> Bytes {
+    let mut buffer = Bytes::from_array(env, &(OPTION_TYPE_3 as u16).to_be_bytes());
+    buffer.extend_from_slice(data);
+    buffer
+}
+
+#[test]
+fn test_set_and_get_enforced_options() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+
+    // Create enforced options for different eid/msg_type combinations
+    let options1 = create_valid_options(&env, &[1, 2, 3, 4]);
+    let options2 = create_valid_options(&env, &[5, 6, 7, 8]);
+
+    let enforced_params = vec![
+        &env,
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: options1.clone() },
+        EnforcedOptionParam { eid: REMOTE_EID_2, msg_type: MSG_TYPE_RECEIVE, options: options2.clone() },
+    ];
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "set_enforced_options",
+            args: (&enforced_params,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    oapp_client.set_enforced_options(&enforced_params);
+
+    // assert events
+    assert_event(&env, &oapp_client.address, EnforcedOptionSet { enforced_option_params: enforced_params.clone() });
+
+    // Verify options were set correctly
+    let retrieved1 = oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND);
+    assert_eq!(retrieved1, options1);
+
+    let retrieved2 = oapp_client.enforced_options(&REMOTE_EID_2, &MSG_TYPE_RECEIVE);
+    assert_eq!(retrieved2, options2);
+}
+
+#[test]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_set_enforced_options_unauthorized() {
+    let TestSetup { env, oapp_client, .. } = setup();
+
+    let options = create_valid_options(&env, &[1, 2, 3, 4]);
+    let enforced_params =
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: options.clone() }];
+    oapp_client.set_enforced_options(&enforced_params);
+}
+
+#[test]
+fn test_combine_options_with_empty_enforced() {
+    let TestSetup { env, oapp_client, .. } = setup();
+
+    let extra_options = create_valid_options(&env, &[9, 10, 11]);
+    // When no enforced options are set, should return extra options
+    let combined = oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra_options);
+    assert_eq!(combined, extra_options);
+}
+
+#[test]
+fn test_combine_options_with_empty_extra() {
+    let TestSetup { env, oapp_client, .. } = setup();
+
+    // This test now simply validates that empty extra options return empty result
+    // when no enforced options are set
+    let empty_extra = Bytes::new(&env);
+    let combined = oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &empty_extra);
+    assert_eq!(combined, empty_extra);
+}
+
+#[test]
+fn test_combine_options_both_present() {
+    let TestSetup { env, oapp_client, .. } = setup();
+    env.mock_all_auths();
+
+    let enforced = create_valid_options(&env, &[1, 2, 3]);
+    oapp_client.set_enforced_options(&vec![
+        &env,
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced.clone() },
+    ]);
+
+    let extra = create_valid_options(&env, &[4, 5, 6]);
+    let combined = oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra);
+
+    let mut expected_combined = enforced;
+    expected_combined.append(&extra.slice(2..));
+
+    // Should return extra options when no enforced options exist
+    assert_eq!(combined, expected_combined);
+}
+
+#[test]
+fn test_update_enforced_options() {
+    let TestSetup { env, oapp_client, .. } = setup();
+    env.mock_all_auths();
+
+    // Set initial options
+    let initial_options = create_valid_options(&env, &[1, 2, 3]);
+    let params = vec![
+        &env,
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: initial_options.clone() },
+    ];
+    oapp_client.set_enforced_options(&params);
+
+    // Verify initial options
+    let retrieved = oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND);
+    assert_eq!(retrieved, initial_options);
+
+    // Update with new options
+    let updated_options = create_valid_options(&env, &[9, 8, 7, 6, 5]);
+    let update_params = vec![
+        &env,
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: updated_options.clone() },
+    ];
+    oapp_client.set_enforced_options(&update_params);
+
+    // Verify options were updated
+    let retrieved_after_update = oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND);
+    assert_eq!(retrieved_after_update, updated_options);
+}
+
+#[test]
+fn test_get_enforced_options_for_unset_combination() {
+    let TestSetup { env, oapp_client, .. } = setup();
+
+    // Try to get options for an eid/msg_type that hasn't been set
+    let result = oapp_client.enforced_options(&999, &999);
+    assert_eq!(result, Bytes::new(&env));
+}

package/contracts/oapps/oapp/src/tests/test_oapp_receiver.rs

@@ -0,0 +1,157 @@
+use crate as oapp;
+use crate::oapp_core::OAppCoreStorage;
+use crate::oapp_receiver::OAppReceiverOverrides;
+use crate::tests::test_oapp_core::DummyEndpoint;
+use crate::{errors::OAppError, oapp_receiver::OAppReceiver};
+use endpoint_v2::{ILayerZeroReceiver, Origin};
+use soroban_sdk::contractimpl;
+use soroban_sdk::{assert_with_error, testutils::Address as _, Address, Bytes, BytesN, Env};
+use utils::option_ext::OptionExt;
+use utils::ownable::Ownable;
+
+#[oapp_macros::oapp_receiver]
+pub struct DummyOAppReceiver;
+
+impl OAppReceiverOverrides for DummyOAppReceiver {
+    fn __lz_receive(
+        _env: &Env,
+        _executor: &Address,
+        _origin: &Origin,
+        _guid: &BytesN<32>,
+        _message: &Bytes,
+        _extra_data: &Bytes,
+        _value: i128,
+    ) {
+        // do nothing
+    }
+}
+
+#[contractimpl]
+impl DummyOAppReceiver {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
+        Self::__init_owner(env, owner);
+        Self::__oapp_initialize(env, endpoint, &None);
+    }
+
+    pub fn assert_allowed_peer(env: &Env, origin: &Origin) {
+        let peer = OAppCoreStorage::peer(env, origin.src_eid).unwrap_or_panic(env, OAppError::NoPeer);
+        assert_with_error!(env, peer == origin.sender, OAppError::OnlyPeer);
+    }
+}
+
+const REMOTE_EID: u32 = 100;
+const UNSET_EID: u32 = 999;
+
+struct TestSetup<'a> {
+    env: Env,
+    #[allow(dead_code)]
+    owner: Address,
+    #[allow(dead_code)]
+    endpoint: Address,
+    #[allow(dead_code)]
+    native_token: Address,
+    oapp_client: DummyOAppReceiverClient<'a>,
+}
+
+fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+
+    let owner = Address::generate(&env);
+    let endpoint = env.register(DummyEndpoint, ());
+    let native_token = Address::generate(&env);
+    let oapp = env.register(DummyOAppReceiver, (&owner, &endpoint));
+    let oapp_client = DummyOAppReceiverClient::new(&env, &oapp);
+    TestSetup { env, owner, endpoint, native_token, oapp_client }
+}
+
+#[test]
+fn test_is_compose_msg_sender_same_contract() {
+    let TestSetup { env, oapp_client, .. } = setup();
+
+    let origin = Origin { src_eid: REMOTE_EID, sender: BytesN::from_array(&env, &[1; 32]), nonce: 1 };
+    let message = Bytes::from_array(&env, &[1, 2, 3, 4]);
+
+    // Test with same contract address (should return true)
+    let result = oapp_client.is_compose_msg_sender(&origin, &message, &oapp_client.address);
+    assert_eq!(result, true);
+}
+
+#[test]
+fn test_is_compose_msg_sender_different_contract() {
+    let TestSetup { env, oapp_client, .. } = setup();
+
+    let origin = Origin { src_eid: REMOTE_EID, sender: BytesN::from_array(&env, &[1; 32]), nonce: 1 };
+    let message = Bytes::from_array(&env, &[1, 2, 3, 4]);
+    let different_sender = Address::generate(&env);
+
+    // Test with different sender address (should return false)
+    let result = oapp_client.is_compose_msg_sender(&origin, &message, &different_sender);
+    assert_eq!(result, false);
+}
+
+#[test]
+fn test_allow_initialize_path_with_matching_peer() {
+    let TestSetup { env, oapp_client, .. } = setup();
+    env.mock_all_auths();
+
+    let peer_bytes: BytesN<32> = BytesN::from_array(&env, &[5; 32]);
+    oapp_client.set_peer(&REMOTE_EID, &Some(peer_bytes.clone()));
+
+    let origin = Origin { src_eid: REMOTE_EID, sender: peer_bytes.clone(), nonce: 1 };
+
+    let result = oapp_client.allow_initialize_path(&origin);
+    assert_eq!(result, true);
+}
+
+#[test]
+fn test_allow_initialize_path_with_non_matching_peer() {
+    let TestSetup { env, oapp_client, .. } = setup();
+    env.mock_all_auths();
+
+    let peer_bytes: BytesN<32> = BytesN::from_array(&env, &[5; 32]);
+    oapp_client.set_peer(&REMOTE_EID, &Some(peer_bytes));
+
+    let different_sender: BytesN<32> = BytesN::from_array(&env, &[6; 32]);
+    let origin = Origin { src_eid: REMOTE_EID, sender: different_sender, nonce: 1 };
+
+    let result = oapp_client.allow_initialize_path(&origin);
+    assert_eq!(result, false);
+}
+
+#[test]
+fn test_allow_initialize_path_with_no_peer_set() {
+    let TestSetup { env, oapp_client, .. } = setup();
+
+    let origin = Origin { src_eid: UNSET_EID, sender: BytesN::from_array(&env, &[5; 32]), nonce: 1 };
+
+    let result = oapp_client.allow_initialize_path(&origin);
+    assert_eq!(result, false);
+}
+
+#[test]
+fn test_assert_allowed_peer_wrong_sender() {
+    let TestSetup { env, oapp_client, .. } = setup();
+    env.mock_all_auths();
+
+    let peer_bytes: BytesN<32> = BytesN::from_array(&env, &[7; 32]);
+    oapp_client.set_peer(&REMOTE_EID, &Some(peer_bytes));
+
+    let wrong_sender: BytesN<32> = BytesN::from_array(&env, &[8; 32]);
+    let origin = Origin { src_eid: REMOTE_EID, sender: wrong_sender, nonce: 1 };
+
+    // This should panic with OnlyPeer error
+    let result = oapp_client.try_assert_allowed_peer(&origin);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::OnlyPeer.into());
+}
+
+#[test]
+fn test_assert_allowed_peer_no_peer() {
+    let TestSetup { env, oapp_client, .. } = setup();
+    env.mock_all_auths();
+
+    let origin = Origin { src_eid: UNSET_EID, sender: BytesN::from_array(&env, &[7; 32]), nonce: 1 };
+
+    // This should panic with NoPeer error
+    let result = oapp_client.try_assert_allowed_peer(&origin);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::NoPeer.into());
+}