@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

package/contracts/message-libs/uln-302/src/tests/send_uln302/set_default_executor_configs.rs

@@ -3,7 +3,7 @@ use soroban_sdk::{
     testutils::{Address as _, MockAuth, MockAuthInvoke},
     vec, Address, IntoVal,
 };
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{
     errors::Uln302Error,
@@ -44,7 +44,7 @@ fn test_set_default_executor_configs() {
     uln302.set_default_executor_configs(&executor_configs);
 
     // Assert DefaultExecutorConfigSet event was published with all params
-    assert_event(&env, &uln302.address, DefaultExecutorConfigsSet { params: executor_configs.clone() });
+    assert_eq_event(&env, &uln302.address, DefaultExecutorConfigsSet { params: executor_configs.clone() });
 
     let uln302_send_client = SendUln302Client::new(&env, &uln302.address);
     for config_param in executor_configs.clone() {

package/contracts/message-libs/uln-302/src/tests/send_uln302/set_default_send_uln_configs.rs

@@ -3,7 +3,7 @@ use soroban_sdk::{
     testutils::{MockAuth, MockAuthInvoke},
     vec, IntoVal,
 };
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{
     errors::Uln302Error,
@@ -34,7 +34,7 @@ fn test_set_default_send_uln_configs() {
     uln302.set_default_send_uln_configs(&oapp_send_uln_configs);
 
     // Assert DefaultSendUlnConfigSet event was published with all params
-    assert_event(&env, &uln302.address, DefaultSendUlnConfigsSet { params: oapp_send_uln_configs.clone() });
+    assert_eq_event(&env, &uln302.address, DefaultSendUlnConfigsSet { params: oapp_send_uln_configs.clone() });
 
     let uln302_send_client = SendUln302Client::new(&env, &uln302.address);
     for config in oapp_send_uln_configs.clone() {

package/contracts/oapps/counter/Cargo.toml

@@ -18,7 +18,6 @@ oapp-macros = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
-assert_unordered = "0.3.5"
 simple-message-lib = { workspace = true }
 message-lib-common = { workspace = true, features = ["testutils"] }
 endpoint-v2 = { workspace = true, features = ["testutils"] }
@@ -27,12 +26,12 @@ uln302 = { workspace = true, features = ["testutils"] }
 dvn = { workspace = true, features = ["testutils"] }
 dvn-fee-lib = { workspace = true }
 executor-fee-lib = { workspace = true }
-worker = { workspace = true }
 treasury = { workspace = true, features = ["testutils"] }
 price-feed = { workspace = true }
+fee-lib-interfaces = { workspace = true }
 executor-helper = { workspace = true }
 # For real DVN signature verification in integration tests
-k256 = "0.13"
-sha3 = "0.10"
-rand = "0.8"
-ed25519-dalek = "2"
+k256 = { workspace = true }
+sha3 = { workspace = true }
+rand = { workspace = true }
+ed25519-dalek = { workspace = true }

package/contracts/oapps/counter/integration_tests/setup_uln.rs

@@ -13,6 +13,7 @@ use endpoint_v2::{EndpointV2, EndpointV2Client};
 use executor::{DstConfig as ExecutorDstConfig, ExecutorClient, LzExecutor, SetDstConfigParam};
 use executor_fee_lib::ExecutorFeeLib;
 use executor_helper::{ExecutorHelper, ExecutorHelperClient};
+use fee_lib_interfaces::Price;
 use price_feed::{types::UpdatePrice, LzPriceFeed};
 use soroban_sdk::{
     testutils::{Address as _, MockAuth, MockAuthInvoke},
@@ -25,7 +26,6 @@ use uln302::{
     Uln302, Uln302Client, UlnConfig,
 };
 use utils::{buffer_reader::BufferReader, buffer_writer::BufferWriter};
-use worker::Price;
 
 pub const CONFIRMATIONS: u64 = 1;
 pub const MAX_MESSAGE_SIZE: u32 = 10000;

package/contracts/oapps/counter/integration_tests/utils.rs

@@ -11,6 +11,7 @@ use soroban_sdk::{
     Address, Bytes, BytesN, Env, IntoVal, Map, Symbol, Val, Vec,
 };
 use utils::buffer_reader::BufferReader;
+use utils::testing_utils::decode_event_topics_data;
 
 /// Trait for common fields in chain setup structs.
 /// Both SML and ULN302 ChainSetup implement this trait.
@@ -215,13 +216,15 @@ pub fn validate_packet<'a, C: ChainSetupCommon<'a>>(
 
 /// Scans for the latest packet_sent event and returns (encoded_payload, options, send_library).
 pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, Bytes, Address)> {
-    let events = env.events().all();
+    let events = env.events().all().filter_by_contract(endpoint);
     let packet_sent_symbol = Symbol::new(env, "packet_sent").to_val();
 
     // Iterate in reverse to find the most recent packet sent event
-    for i in (0..events.len()).rev() {
-        let (emitter, topics, data) = events.get(i).unwrap();
-        if emitter == *endpoint && topics.contains(packet_sent_symbol) {
+    for event in events.events().iter().rev() {
+        let Some((topics, data)) = decode_event_topics_data(env, event) else {
+            continue;
+        };
+        if topics.contains(packet_sent_symbol) {
             let map: Map<Symbol, Val> = data.into_val(env);
 
             let encoded_payload: Bytes = map.get(Symbol::new(env, "encoded_packet")).unwrap().into_val(env);
@@ -240,13 +243,15 @@ pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, B
 /// Use this only after all messages have been sent in a single "transaction" or collect events incrementally.
 #[allow(dead_code)]
 pub fn scan_all_packet_sent_events(env: &Env, endpoint: &Address) -> Vec<(Bytes, Bytes, Address)> {
-    let events = env.events().all();
+    let events = env.events().all().filter_by_contract(endpoint);
     let packet_sent_symbol = Symbol::new(env, "packet_sent").to_val();
     let mut result = Vec::new(env);
 
-    for i in 0..events.len() {
-        let (emitter, topics, data) = events.get(i).unwrap();
-        if emitter == *endpoint && topics.contains(packet_sent_symbol) {
+    for event in events.events().iter() {
+        let Some((topics, data)) = decode_event_topics_data(env, event) else {
+            continue;
+        };
+        if topics.contains(packet_sent_symbol) {
             let map: Map<Symbol, Val> = data.into_val(env);
 
             let encoded_payload: Bytes = map.get(Symbol::new(env, "encoded_packet")).unwrap().into_val(env);
@@ -265,13 +270,15 @@ pub type ComposeSentEvent = (Address, Address, BytesN<32>, u32, Bytes);
 
 /// Scans for the latest compose_sent event and returns (from, to, guid, index, message).
 pub fn scan_compose_sent_event(env: &Env, endpoint: &Address) -> Option<ComposeSentEvent> {
-    let events = env.events().all();
+    let events = env.events().all().filter_by_contract(endpoint);
     let compose_sent_symbol = Symbol::new(env, "compose_sent").to_val();
 
     // Iterate in reverse to find the most recent compose sent event
-    for i in (0..events.len()).rev() {
-        let (emitter, topics, data) = events.get(i).unwrap();
-        if emitter == *endpoint && topics.contains(compose_sent_symbol) {
+    for event in events.events().iter().rev() {
+        let Some((topics, data)) = decode_event_topics_data(env, event) else {
+            continue;
+        };
+        if topics.contains(compose_sent_symbol) {
             let map: Map<Symbol, Val> = data.into_val(env);
             let from: Address = topics.get(1).unwrap().into_val(env);
             let to: Address = topics.get(2).unwrap().into_val(env);

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

@@ -1,7 +1,7 @@
 use common_macros::contract_error;
 
 // OApp library error codes: 2000-2099
-// See ERROR_SPEC.md for allocation rules
+// See docs/error-spec.md for allocation rules
 
 /// OAppError: 2000-2099
 #[contract_error]

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

@@ -0,0 +1,3 @@
+mod oapp_msg_inspector;
+
+pub use oapp_msg_inspector::*;

package/contracts/oapps/oapp/src/interfaces/oapp_msg_inspector.rs

@@ -0,0 +1,47 @@
+//! OApp Message Inspector interface.
+//!
+//! This module defines the `IOAppMsgInspector` trait that external inspector contracts
+//! must implement to validate outgoing LayerZero messages and options.
+//!
+//! ## Usage
+//!
+//! Inspector contracts should implement this trait and panic if inspection fails:
+//!
+//! ```ignore
+//! use oapp::interfaces::IOAppMsgInspector;
+//!
+//! pub struct MyInspector;
+//!
+//! #[contractimpl]
+//! impl IOAppMsgInspector for MyInspector {
+//!     fn inspect(env: &Env, oapp: &Address, message: &Bytes, options: &Bytes) {
+//!         // Validate message and options
+//!         // Panic if invalid
+//!         if !is_valid(message, options) {
+//!             panic_with_error!(env, MyError::InspectionFailed);
+//!         }
+//!     }
+//! }
+//! ```
+
+use soroban_sdk::{contractclient, Address, Bytes, Env};
+
+/// Interface for OApp message inspectors.
+///
+/// Contracts implementing this trait can be set as message inspectors on OFT contracts
+/// to validate outgoing messages and options before they are sent cross-chain.
+///
+/// If inspection fails, the implementation should panic to revert the transaction.
+#[contractclient(name = "OAppMsgInspectorClient")]
+pub trait IOAppMsgInspector {
+    /// Inspects the LayerZero message and options before sending.
+    ///
+    /// # Arguments
+    /// * `oapp` - The address of the OApp contract sending the message
+    /// * `message` - The encoded message payload to be sent
+    /// * `options` - The LayerZero options for the message
+    ///
+    /// # Panics
+    /// Should panic if the message or options are invalid, reverting the transaction.
+    fn inspect(env: &Env, oapp: &Address, message: &Bytes, options: &Bytes);
+}

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

@@ -1,6 +1,7 @@
 #![no_std]
 
 pub mod errors;
+pub mod interfaces;
 pub mod oapp_core;
 pub mod oapp_options_type3;
 pub mod oapp_receiver;

package/contracts/oapps/oapp/src/macro_tests/test_macros.rs

@@ -149,10 +149,10 @@ mod test_full_manual_options {
     extern crate self as oapp;
 
     use endpoint_v2::Origin;
-    use oapp::oapp_options_type3::{EnforcedOptionParam, OAppOptionsType3};
+    use oapp::oapp_options_type3::OAppOptionsType3;
     use oapp::oapp_receiver::LzReceiveInternal;
     use oapp_macros::oapp;
-    use soroban_sdk::{contractimpl, Address, Bytes, BytesN, Env, Vec};
+    use soroban_sdk::{contractimpl, Address, Bytes, BytesN, Env};
 
     #[oapp(custom = [options_type3])]
     struct TestFullManualOptions;
@@ -354,12 +354,12 @@ mod test_full_manual_all {
     use endpoint_v2::Origin;
     use oapp::{
         oapp_core::OAppCore,
-        oapp_options_type3::{EnforcedOptionParam, OAppOptionsType3},
+        oapp_options_type3::OAppOptionsType3,
         oapp_receiver::{LzReceiveInternal, OAppReceiver},
         oapp_sender::OAppSenderInternal,
     };
     use oapp_macros::oapp;
-    use soroban_sdk::{contractimpl, Address, Bytes, BytesN, Env, Vec};
+    use soroban_sdk::{contractimpl, Address, Bytes, BytesN, Env};
 
     #[oapp(custom = [core, sender, receiver, options_type3])]
     struct TestFullManualAll;

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

@@ -57,7 +57,7 @@ pub trait OAppCore: Ownable {
     /// A tuple containing:
     /// - `sender_version`: The version of the OAppSender
     /// - `receiver_version`: The version of the OAppReceiver
-    fn oapp_version(_env: &Env) -> (u64, u64) {
+    fn oapp_version(_env: &soroban_sdk::Env) -> (u64, u64) {
         (1, 1)
     }
 
@@ -65,7 +65,7 @@ pub trait OAppCore: Ownable {
     ///
     /// # Returns
     /// The LayerZero endpoint address
-    fn endpoint(env: &Env) -> Address {
+    fn endpoint(env: &soroban_sdk::Env) -> soroban_sdk::Address {
         OAppCoreStorage::endpoint(env).unwrap()
     }
 
@@ -76,7 +76,7 @@ pub trait OAppCore: Ownable {
     ///
     /// # Returns
     /// The peer address (OApp instance) associated with the corresponding endpoint
-    fn peer(env: &Env, eid: u32) -> Option<BytesN<32>> {
+    fn peer(env: &soroban_sdk::Env, eid: u32) -> Option<soroban_sdk::BytesN<32>> {
         OAppCoreStorage::peer(env, eid)
     }
 
@@ -86,7 +86,7 @@ pub trait OAppCore: Ownable {
     /// * `eid` - The endpoint ID
     /// * `peer` - The address of the peer to be associated with the corresponding endpoint, or None to remove the peer
     #[only_auth]
-    fn set_peer(env: &Env, eid: u32, peer: &Option<BytesN<32>>) {
+    fn set_peer(env: &soroban_sdk::Env, eid: u32, peer: &Option<soroban_sdk::BytesN<32>>) {
         OAppCoreStorage::set_or_remove_peer(env, eid, peer);
         PeerSet { eid, peer: peer.clone() }.publish(env);
     }
@@ -96,7 +96,7 @@ pub trait OAppCore: Ownable {
     /// # Arguments
     /// * `delegate` - The address of the delegate to be set, or None to remove the delegate
     #[only_auth]
-    fn set_delegate(env: &Env, delegate: &Option<Address>) {
+    fn set_delegate(env: &soroban_sdk::Env, delegate: &Option<soroban_sdk::Address>) {
         endpoint_client::<Self>(env).set_delegate(&env.current_contract_address(), delegate);
     }
 }

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

@@ -1,4 +1,4 @@
-use crate::errors::OAppError;
+use crate::{self as oapp, errors::OAppError};
 use common_macros::{contract_trait, only_auth, storage};
 use soroban_sdk::{assert_with_error, contractevent, contracttype, panic_with_error, Bytes, Env, Vec};
 use utils::{buffer_reader::BufferReader, ownable::Ownable};
@@ -40,7 +40,7 @@ pub trait OAppOptionsType3: Ownable {
     ///
     /// # Returns
     /// The enforced options for the given endpoint and message type
-    fn enforced_options(env: &Env, eid: u32, msg_type: u32) -> Bytes {
+    fn enforced_options(env: &soroban_sdk::Env, eid: u32, msg_type: u32) -> soroban_sdk::Bytes {
         OAppOptionsType3Storage::enforced_options(env, eid, msg_type)
     }
 
@@ -55,7 +55,10 @@ pub trait OAppOptionsType3: Ownable {
     /// # Arguments
     /// * `options` - A vector of EnforcedOptionParam structures specifying enforced options
     #[only_auth]
-    fn set_enforced_options(env: &Env, options: Vec<EnforcedOptionParam>) {
+    fn set_enforced_options(
+        env: &soroban_sdk::Env,
+        options: soroban_sdk::Vec<oapp::oapp_options_type3::EnforcedOptionParam>,
+    ) {
         for option in &options {
             assert_option_type3(env, &option.options);
             OAppOptionsType3Storage::set_enforced_options(env, option.eid, option.msg_type, &option.options);
@@ -77,7 +80,12 @@ pub trait OAppOptionsType3: Ownable {
     ///
     /// # Returns
     /// The combination of caller specified options AND enforced options
-    fn combine_options(env: &Env, eid: u32, msg_type: u32, extra_options: &Bytes) -> Bytes {
+    fn combine_options(
+        env: &soroban_sdk::Env,
+        eid: u32,
+        msg_type: u32,
+        extra_options: &soroban_sdk::Bytes,
+    ) -> soroban_sdk::Bytes {
         let mut enforced_options = Self::enforced_options(env, eid, msg_type);
 
         if enforced_options.is_empty() {

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

@@ -78,7 +78,7 @@ pub trait OAppReceiver: OAppCore + LzReceiveInternal {
     ///
     /// # Returns
     /// True if the path can be initialized, false otherwise
-    fn allow_initialize_path(env: &Env, origin: &Origin) -> bool {
+    fn allow_initialize_path(env: &soroban_sdk::Env, origin: &endpoint_v2::Origin) -> bool {
         let peer = Self::peer(env, origin.src_eid);
         peer.is_some_and(|peer| peer == origin.sender)
     }
@@ -96,7 +96,7 @@ pub trait OAppReceiver: OAppCore + LzReceiveInternal {
     ///
     /// # Returns
     /// The next nonce
-    fn next_nonce(_env: &Env, _src_eid: u32, _sender: &BytesN<32>) -> u64 {
+    fn next_nonce(_env: &soroban_sdk::Env, _src_eid: u32, _sender: &soroban_sdk::BytesN<32>) -> u64 {
         0
     }
 
@@ -116,12 +116,12 @@ pub trait OAppReceiver: OAppCore + LzReceiveInternal {
     /// * `extra_data` - Additional arbitrary data provided by the corresponding executor
     /// * `value` - The native token value sent with the message
     fn lz_receive(
-        env: &Env,
-        executor: &Address,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        extra_data: &Bytes,
+        env: &soroban_sdk::Env,
+        executor: &soroban_sdk::Address,
+        origin: &endpoint_v2::Origin,
+        guid: &soroban_sdk::BytesN<32>,
+        message: &soroban_sdk::Bytes,
+        extra_data: &soroban_sdk::Bytes,
         value: i128,
     ) {
         clear_payload_and_transfer::<Self>(env, executor, origin, guid, message, value);
@@ -140,7 +140,12 @@ pub trait OAppReceiver: OAppCore + LzReceiveInternal {
     ///
     /// # 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 {
+    fn is_compose_msg_sender(
+        env: &soroban_sdk::Env,
+        _origin: &endpoint_v2::Origin,
+        _message: &soroban_sdk::Bytes,
+        sender: &soroban_sdk::Address,
+    ) -> bool {
         env.current_contract_address() == *sender
     }
 }

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

@@ -1,4 +1,4 @@
-mod test_oapp_core;
-mod test_oapp_options_type3;
-mod test_oapp_receiver;
-mod test_oapp_sender;
+mod oapp_core;
+mod oapp_options_type3;
+mod oapp_receiver;
+mod oapp_sender;

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

@@ -0,0 +1,223 @@
+use crate::{self as oapp, oapp_core::PeerSet, oapp_receiver::LzReceiveInternal};
+use endpoint_v2::Origin;
+use soroban_sdk::{
+    contract, contractimpl, contracttype,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Bytes, BytesN, Env, IntoVal,
+};
+use utils::testing_utils::assert_eq_event;
+
+#[contract]
+pub struct DummyEndpoint;
+
+#[derive(Clone)]
+#[contracttype]
+enum DummyEndpointDataKey {
+    Delegate(Address),
+}
+
+#[contractimpl]
+impl DummyEndpoint {
+    pub fn set_delegate(env: Env, oapp: &Address, delegate: &Option<Address>) {
+        let key = DummyEndpointDataKey::Delegate(oapp.clone());
+        match delegate {
+            Some(d) => env.storage().persistent().set(&key, d),
+            None => env.storage().persistent().remove(&key),
+        }
+    }
+
+    pub fn get_delegate(env: Env, oapp: Address) -> Option<Address> {
+        env.storage().persistent().get(&DummyEndpointDataKey::Delegate(oapp))
+    }
+}
+
+#[oapp_macros::oapp]
+pub struct DummyOApp;
+
+impl LzReceiveInternal for DummyOApp {
+    fn __lz_receive(
+        _env: &Env,
+        _origin: &Origin,
+        _guid: &BytesN<32>,
+        _message: &Bytes,
+        _extra_data: &Bytes,
+        _executor: &Address,
+        _value: i128,
+    ) {
+        // Not used in core tests
+    }
+}
+
+#[contractimpl]
+impl DummyOApp {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
+        oapp::oapp_core::initialize_oapp::<Self>(env, owner, 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 }
+}
+
+fn set_peer_with_auth(
+    env: &Env,
+    signer: &Address,
+    oapp_client: &DummyOAppClient<'_>,
+    eid: u32,
+    peer: &Option<BytesN<32>>,
+) {
+    env.mock_auths(&[MockAuth {
+        address: signer,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "set_peer",
+            args: (&eid, peer).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    oapp_client.set_peer(&eid, peer);
+}
+
+fn set_delegate_with_auth(env: &Env, signer: &Address, oapp_client: &DummyOAppClient<'_>, delegate: &Option<Address>) {
+    env.mock_auths(&[MockAuth {
+        address: signer,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "set_delegate",
+            args: (delegate,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    oapp_client.set_delegate(delegate);
+}
+
+#[test]
+fn test_constructor_initializes_owner_and_endpoint_and_clears_delegate() {
+    let TestSetup { env, owner, endpoint, oapp_client } = setup();
+
+    // owner initialized via oapp_initialize -> init_owner
+    assert_eq!(Some(owner), oapp_client.owner());
+
+    // endpoint stored via OAppCoreStorage::set_endpoint
+    assert_eq!(endpoint, oapp_client.endpoint());
+
+    // delegate set via oapp_initialize(..., &None) -> endpoint.set_delegate(..., None)
+    let endpoint_client = DummyEndpointClient::new(&env, &endpoint);
+    assert_eq!(None, endpoint_client.get_delegate(&oapp_client.address));
+}
+
+#[test]
+fn test_oapp_version_defaults_to_zero() {
+    let TestSetup { oapp_client, .. } = setup();
+    assert_eq!((1, 1), oapp_client.oapp_version());
+}
+
+#[test]
+fn test_peer_lifecycle_set_get_update_remove_and_events() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+
+    // Unset cases
+    assert_eq!(None, oapp_client.peer(&UNSET_EID));
+    assert_eq!(None, oapp_client.peer(&REMOTE_EID));
+
+    // Set peer v1
+    let peer_v1: BytesN<32> = BytesN::from_array(&env, &[33; 32]);
+    let peer_v1_option = Some(peer_v1.clone());
+    set_peer_with_auth(&env, &owner, &oapp_client, REMOTE_EID, &peer_v1_option);
+
+    assert_eq_event(&env, &oapp_client.address, PeerSet { eid: REMOTE_EID, peer: Some(peer_v1.clone()) });
+    assert_eq!(Some(peer_v1), oapp_client.peer(&REMOTE_EID));
+    assert_eq!(None, oapp_client.peer(&UNSET_EID));
+
+    // Update to peer v2
+    let peer_v2: BytesN<32> = BytesN::from_array(&env, &[2; 32]);
+    let peer_v2_option = Some(peer_v2.clone());
+    set_peer_with_auth(&env, &owner, &oapp_client, REMOTE_EID, &peer_v2_option);
+
+    assert_eq_event(&env, &oapp_client.address, PeerSet { eid: REMOTE_EID, peer: Some(peer_v2.clone()) });
+    assert_eq!(Some(peer_v2), oapp_client.peer(&REMOTE_EID));
+
+    // Remove peer
+    let none_peer: Option<BytesN<32>> = None;
+    set_peer_with_auth(&env, &owner, &oapp_client, REMOTE_EID, &none_peer);
+    assert_eq_event(&env, &oapp_client.address, PeerSet { eid: REMOTE_EID, peer: None });
+    assert_eq!(None, oapp_client.peer(&REMOTE_EID));
+}
+
+#[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]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_set_peer_non_owner_authorized() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+    let non_owner = Address::generate(&env);
+    assert!(non_owner != owner);
+
+    let peer: BytesN<32> = BytesN::from_array(&env, &[33; 32]);
+    let peer_option = Some(peer);
+    set_peer_with_auth(&env, &non_owner, &oapp_client, REMOTE_EID, &peer_option);
+}
+
+#[test]
+fn test_set_delegate_updates_and_clears_endpoint_delegate() {
+    let TestSetup { env, owner, endpoint, oapp_client } = setup();
+
+    let delegate = Address::generate(&env);
+    let delegate_option = Some(delegate.clone());
+    set_delegate_with_auth(&env, &owner, &oapp_client, &delegate_option);
+
+    let endpoint_client = DummyEndpointClient::new(&env, &endpoint);
+    assert_eq!(Some(delegate), endpoint_client.get_delegate(&oapp_client.address));
+
+    // Clear delegate
+    let none_delegate: Option<Address> = None;
+    set_delegate_with_auth(&env, &owner, &oapp_client, &none_delegate);
+    assert_eq!(None, endpoint_client.get_delegate(&oapp_client.address));
+}
+
+#[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]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_set_delegate_non_owner_authorized() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+    let non_owner = Address::generate(&env);
+    assert!(non_owner != owner);
+
+    let delegate = Address::generate(&env);
+    let delegate_option = Some(delegate);
+    set_delegate_with_auth(&env, &non_owner, &oapp_client, &delegate_option);
+}