@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.20

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

@@ -1,7 +1,7 @@
 use crate::{self as oapp, oapp_core::PeerSet, oapp_receiver::LzReceiveInternal};
 use endpoint_v2::Origin;
 use soroban_sdk::{
-    contract, contractimpl,
+    contract, contractimpl, contracttype,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
     Address, Bytes, BytesN, Env, IntoVal,
 };
@@ -10,10 +10,24 @@ use utils::testing_utils::assert_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>) {
-        // do nothing
+    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))
     }
 }
 
@@ -64,97 +78,127 @@ fn setup<'a>() -> TestSetup<'a> {
     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());
+fn set_peer_with_auth(
+    env: &Env,
+    signer: &Address,
+    oapp_client: &DummyOAppClient<'_>,
+    eid: u32,
+    peer: &Option<BytesN<32>>,
+) {
     env.mock_auths(&[MockAuth {
-        address: &owner,
+        address: signer,
         invoke: &MockAuthInvoke {
             contract: &oapp_client.address,
             fn_name: "set_peer",
-            args: (&REMOTE_EID, &test_peer_option).into_val(&env),
+            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_peer(&REMOTE_EID, &test_peer_option);
+    oapp_client.set_delegate(delegate);
+}
 
-    // assert event
-    assert_event(&env, &oapp_client.address, PeerSet { eid: REMOTE_EID, peer: Some(test_peer.clone()) });
+#[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());
 
-    // Test getting peer for set eid
-    let retrieved_peer = oapp_client.peer(&REMOTE_EID);
-    assert_eq!(Some(test_peer), retrieved_peer);
+    // endpoint stored via OAppCoreStorage::set_endpoint
+    assert_eq!(endpoint, oapp_client.endpoint());
 
-    // Test getting peer for unset eid
-    let retrieved_peer = oapp_client.peer(&UNSET_EID);
-    assert_eq!(None, retrieved_peer);
+    // 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]
-#[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));
+fn test_oapp_version_defaults_to_zero() {
+    let TestSetup { oapp_client, .. } = setup();
+    assert_eq!((1, 1), oapp_client.oapp_version());
 }
 
 #[test]
-fn test_get_peer_success() {
-    let TestSetup { env, oapp_client, .. } = setup();
-    env.mock_all_auths();
+fn test_peer_lifecycle_set_get_update_remove_and_events() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
 
-    let test_peer: BytesN<32> = BytesN::from_array(&env, &[1; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(test_peer.clone()));
+    // Unset cases
+    assert_eq!(None, oapp_client.peer(&UNSET_EID));
+    assert_eq!(None, oapp_client.peer(&REMOTE_EID));
 
-    let retrieved_peer = oapp_client.peer(&REMOTE_EID);
-    assert_eq!(Some(test_peer), retrieved_peer);
-}
+    // 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);
 
-#[test]
-fn test_get_peer_returns_none_for_unset_eid() {
-    let TestSetup { oapp_client, .. } = setup();
+    assert_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));
 
-    let result = oapp_client.peer(&UNSET_EID);
-    assert_eq!(result, None);
+    // 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_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_event(&env, &oapp_client.address, PeerSet { eid: REMOTE_EID, peer: None });
+    assert_eq!(None, oapp_client.peer(&REMOTE_EID));
 }
 
 #[test]
-fn test_update_peer() {
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_set_peer_unauthorized() {
     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));
+    let test_peer: BytesN<32> = BytesN::from_array(&env, &[33; 32]);
+    oapp_client.set_peer(&REMOTE_EID, &Some(test_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()));
+#[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 retrieved_peer = oapp_client.peer(&REMOTE_EID);
-    assert_eq!(Some(updated_peer), retrieved_peer);
+    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() {
-    let TestSetup { env, owner, oapp_client, .. } = setup();
+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());
-    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);
+    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]
@@ -167,9 +211,13 @@ fn test_set_delegate_unauthorized() {
 }
 
 #[test]
-fn test_get_endpoint() {
-    let TestSetup { endpoint, oapp_client, .. } = setup();
+#[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 retrieved_endpoint = oapp_client.endpoint();
-    assert_eq!(endpoint, retrieved_endpoint);
+    let delegate = Address::generate(&env);
+    let delegate_option = Some(delegate);
+    set_delegate_with_auth(&env, &non_owner, &oapp_client, &delegate_option);
 }

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

@@ -1,5 +1,6 @@
 use crate::{
     self as oapp,
+    errors::OAppError,
     oapp_core::OAppCore,
     oapp_options_type3::{EnforcedOptionParam, EnforcedOptionSet},
     oapp_receiver::{LzReceiveInternal, OAppReceiver},
@@ -83,40 +84,82 @@ fn create_valid_options(env: &Env, data: &[u8]) -> Bytes {
     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() },
-    ];
+fn set_enforced_options_with_auth(
+    env: &Env,
+    signer: &Address,
+    oapp_client: &DummyOAppOptionsType3Client<'_>,
+    enforced_params: &soroban_sdk::Vec<EnforcedOptionParam>,
+) {
     env.mock_auths(&[MockAuth {
-        address: &owner,
+        address: signer,
         invoke: &MockAuthInvoke {
             contract: &oapp_client.address,
             fn_name: "set_enforced_options",
-            args: (&enforced_params,).into_val(&env),
+            args: (enforced_params,).into_val(env),
             sub_invokes: &[],
         },
     }]);
+    oapp_client.set_enforced_options(enforced_params);
+}
 
-    oapp_client.set_enforced_options(&enforced_params);
+#[test]
+fn test_enforced_options_lifecycle() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+
+    // Unset returns empty
+    assert_eq!(oapp_client.enforced_options(&999, &999), Bytes::new(&env));
+
+    // Set enforced options for different eid/msg_type combinations
+    let enforced1 = create_valid_options(&env, &[1, 2, 3, 4]);
+    let enforced2 = create_valid_options(&env, &[5, 6, 7, 8]);
+    let enforced_params = vec![
+        &env,
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced1.clone() },
+        EnforcedOptionParam { eid: REMOTE_EID_2, msg_type: MSG_TYPE_RECEIVE, options: enforced2.clone() },
+    ];
+    set_enforced_options_with_auth(&env, &owner, &oapp_client, &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);
+    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), enforced1.clone());
+    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_2, &MSG_TYPE_RECEIVE), enforced2.clone());
+
+    // Update enforced options for one combination
+    let updated = 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.clone() }];
+    set_enforced_options_with_auth(&env, &owner, &oapp_client, &update_params);
+    assert_event(&env, &oapp_client.address, EnforcedOptionSet { enforced_option_params: update_params.clone() });
+    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), updated);
+}
+
+#[test]
+fn test_combine_options() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+
+    // combine_options: no enforced -> returns extra (including empty)
+    let extra_only = create_valid_options(&env, &[9, 10, 11]);
+    assert_eq!(oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra_only), extra_only);
+
+    let empty_extra = Bytes::new(&env);
+    assert_eq!(oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &empty_extra), empty_extra);
+
+    // Set enforced options for the combine tests
+    let enforced = create_valid_options(&env, &[1, 2, 3, 4]);
+    let enforced_params =
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced.clone() }];
+    set_enforced_options_with_auth(&env, &owner, &oapp_client, &enforced_params);
 
-    let retrieved2 = oapp_client.enforced_options(&REMOTE_EID_2, &MSG_TYPE_RECEIVE);
-    assert_eq!(retrieved2, options2);
+    // combine_options: enforced present -> empty extra returns enforced
+    assert_eq!(oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &Bytes::new(&env)), enforced.clone());
+
+    // combine_options: both present -> enforced + extra(without its 2-byte header)
+    let extra: Bytes = create_valid_options(&env, &[4, 5, 6]);
+    let combined = oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra);
+    let expected_combined = create_valid_options(&env, &[1, 2, 3, 4, 4, 5, 6]);
+    assert_eq!(combined, expected_combined);
 }
 
 #[test]
@@ -131,82 +174,68 @@ fn test_set_enforced_options_unauthorized() {
 }
 
 #[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);
-}
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_set_enforced_options_non_owner_authorized() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+    let non_owner = Address::generate(&env);
+    assert!(non_owner != owner);
 
-#[test]
-fn test_combine_options_with_empty_extra() {
-    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() }];
 
-    // 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);
+    set_enforced_options_with_auth(&env, &non_owner, &oapp_client, &enforced_params);
 }
 
 #[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() },
-    ]);
+fn test_set_enforced_options_invalid_options_returns_error() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
 
-    let extra = create_valid_options(&env, &[4, 5, 6]);
-    let combined = oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra);
+    // wrong option type (not 3)
+    let mut invalid = Bytes::from_array(&env, &(4u16).to_be_bytes());
+    invalid.extend_from_slice(&[1, 2, 3]);
 
-    let mut expected_combined = enforced;
-    expected_combined.append(&extra.slice(2..));
+    let enforced_params =
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: invalid }];
 
-    // Should return extra options when no enforced options exist
-    assert_eq!(combined, expected_combined);
+    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: &[],
+        },
+    }]);
+    let result = oapp_client.try_set_enforced_options(&enforced_params);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
 }
 
 #[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);
+fn test_combine_options_extra_invalid_type_returns_error_when_enforced_present() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
 
-    // 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);
+    let enforced = create_valid_options(&env, &[1, 2, 3]);
+    let params = vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced }];
+    set_enforced_options_with_auth(&env, &owner, &oapp_client, &params);
+
+    // extra has wrong option type (not 3) but len >= 2 -> validated and should panic
+    let mut extra_invalid = Bytes::from_array(&env, &(4u16).to_be_bytes());
+    extra_invalid.extend_from_slice(&[9, 9, 9]);
+    let result = oapp_client.try_combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra_invalid);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
 }
 
 #[test]
-fn test_get_enforced_options_for_unset_combination() {
-    let TestSetup { env, oapp_client, .. } = setup();
+fn test_combine_options_extra_too_short_returns_error_when_enforced_present() {
+    let TestSetup { env, owner, oapp_client, .. } = setup();
+
+    let enforced = create_valid_options(&env, &[1, 2, 3]);
+    let params = vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced }];
+    set_enforced_options_with_auth(&env, &owner, &oapp_client, &params);
 
-    // 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));
+    // extra is non-empty but len < 2 -> should panic
+    let extra_too_short = Bytes::from_array(&env, &[1u8]);
+    let result = oapp_client.try_combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra_too_short);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
 }