@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

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

@@ -1,225 +0,0 @@
-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]
-#[common_macros::lz_contract]
-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::init_ownable_oapp::<Self>(env, owner, endpoint, owner);
-    }
-}
-
-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, signer).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    oapp_client.set_peer(&eid, peer, signer);
-}
-
-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, signer).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    oapp_client.set_delegate(delegate, signer);
-}
-
-#[test]
-fn test_constructor_initializes_owner_and_endpoint_and_delegate() {
-    let TestSetup { env, owner, endpoint, oapp_client } = setup();
-
-    // owner initialized via oapp_initialize -> init_owner
-    assert_eq!(Some(owner.clone()), oapp_client.owner());
-
-    // endpoint stored via OAppCoreStorage::set_endpoint
-    assert_eq!(endpoint, oapp_client.endpoint());
-
-    // delegate set via oapp_initialize(..., owner) -> endpoint.set_delegate(..., Some(owner))
-    let endpoint_client = DummyEndpointClient::new(&env, &endpoint);
-    assert_eq!(Some(owner), 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, owner, oapp_client, .. } = setup();
-
-    let test_peer: BytesN<32> = BytesN::from_array(&env, &[33; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(test_peer), &owner);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1086)")] // RbacError::Unauthorized
-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, owner, oapp_client, .. } = setup();
-
-    let delegate = Address::generate(&env);
-    oapp_client.set_delegate(&Some(delegate), &owner);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1086)")] // RbacError::Unauthorized
-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);
-}

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

@@ -1,246 +0,0 @@
-use crate::{
-    self as oapp,
-    errors::OAppError,
-    oapp_core::OAppCore,
-    oapp_options_type3::{EnforcedOptionParam, EnforcedOptionSet},
-    oapp_receiver::{LzReceiveInternal, OAppReceiver},
-};
-use common_macros::contract_impl;
-use soroban_sdk::{
-    contract, contractimpl,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    vec, Address, Bytes, BytesN, Env, IntoVal,
-};
-use utils::testing_utils::assert_eq_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]
-pub struct DummyEndpoint;
-
-#[contractimpl]
-impl DummyEndpoint {
-    pub fn set_delegate(_env: Env, _oapp: &Address, _delegate: &Option<Address>) {
-        // do nothing
-    }
-}
-
-#[oapp_macros::oapp(custom = [core, sender, receiver])]
-#[common_macros::lz_contract]
-pub struct DummyOAppOptionsType3;
-
-#[contract_impl(contracttrait)]
-impl utils::rbac::RoleBasedAccessControl for DummyOAppOptionsType3 {}
-
-#[contract_impl(contracttrait)]
-impl OAppCore for DummyOAppOptionsType3 {}
-
-impl LzReceiveInternal for DummyOAppOptionsType3 {
-    fn __lz_receive(
-        _env: &Env,
-        _origin: &endpoint_v2::Origin,
-        _guid: &BytesN<32>,
-        _message: &Bytes,
-        _extra_data: &Bytes,
-        _executor: &Address,
-        _value: i128,
-    ) {
-        // Dummy implementation for testing
-    }
-}
-
-#[contract_impl(contracttrait)]
-impl OAppReceiver for DummyOAppOptionsType3 {}
-
-#[contract_impl]
-impl DummyOAppOptionsType3 {
-    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Address) {
-        oapp::oapp_core::init_ownable_oapp::<Self>(env, owner, endpoint, delegate);
-    }
-}
-
-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 endpoint = env.register(DummyEndpoint, ());
-    let delegate = owner.clone();
-    let oapp = env.register(DummyOAppOptionsType3, (&owner, &endpoint, &delegate));
-    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
-}
-
-fn set_enforced_options_with_auth(
-    env: &Env,
-    signer: &Address,
-    oapp_client: &DummyOAppOptionsType3Client<'_>,
-    enforced_params: &soroban_sdk::Vec<EnforcedOptionParam>,
-) {
-    env.mock_auths(&[MockAuth {
-        address: signer,
-        invoke: &MockAuthInvoke {
-            contract: &oapp_client.address,
-            fn_name: "set_enforced_options",
-            args: (enforced_params, signer).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    oapp_client.set_enforced_options(enforced_params, signer);
-}
-
-#[test]
-fn test_enforced_options_lifecycle() {
-    let TestSetup { env, owner, oapp_client, .. } = setup();
-
-    // Unset returns None
-    assert_eq!(oapp_client.enforced_options(&999, &999), None);
-
-    // 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: Some(enforced1.clone()) },
-        EnforcedOptionParam { eid: REMOTE_EID_2, msg_type: MSG_TYPE_RECEIVE, options: Some(enforced2.clone()) },
-    ];
-    set_enforced_options_with_auth(&env, &owner, &oapp_client, &enforced_params);
-
-    // assert events
-    assert_eq_event(&env, &oapp_client.address, EnforcedOptionSet { enforced_options: enforced_params.clone() });
-
-    // Verify options were set correctly
-    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), Some(enforced1.clone()));
-    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_2, &MSG_TYPE_RECEIVE), Some(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: Some(updated.clone()) }];
-    set_enforced_options_with_auth(&env, &owner, &oapp_client, &update_params);
-    assert_eq_event(&env, &oapp_client.address, EnforcedOptionSet { enforced_options: update_params.clone() });
-    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), Some(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: Some(enforced.clone()) }];
-    set_enforced_options_with_auth(&env, &owner, &oapp_client, &enforced_params);
-
-    // 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]
-#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
-fn test_set_enforced_options_unauthorized() {
-    let TestSetup { env, owner, 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: Some(options.clone()) }];
-    oapp_client.set_enforced_options(&enforced_params, &owner);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1086)")] // RbacError::Unauthorized
-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);
-
-    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: Some(options.clone()) }];
-
-    set_enforced_options_with_auth(&env, &non_owner, &oapp_client, &enforced_params);
-}
-
-#[test]
-fn test_set_enforced_options_invalid_options_returns_error() {
-    let TestSetup { env, owner, oapp_client, .. } = setup();
-
-    // wrong option type (not 3)
-    let mut invalid = Bytes::from_array(&env, &(4u16).to_be_bytes());
-    invalid.extend_from_slice(&[1, 2, 3]);
-
-    let enforced_params =
-        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(invalid) }];
-
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &oapp_client.address,
-            fn_name: "set_enforced_options",
-            args: (&enforced_params, &owner).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    let result = oapp_client.try_set_enforced_options(&enforced_params, &owner);
-    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
-}
-
-#[test]
-fn test_combine_options_extra_invalid_type_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: Some(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_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: Some(enforced) }];
-    set_enforced_options_with_auth(&env, &owner, &oapp_client, &params);
-
-    // 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());
-}