@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

package/contracts/macro-integration-tests/tests/runtime/multisig/admin_entrypoints.rs

@@ -1,242 +0,0 @@
-// Runtime tests: `#[multisig]` ensures the contract implements `utils::multisig::MultiSig`.
-//
-// We exercise:
-// - `set_signer` / `set_threshold` behavior (via direct trait calls inside `as_contract`)
-// - `verify_signatures` / `verify_n_signatures` error paths (via exported contract entrypoints)
-
-use super::{TestContract, TestContractClient};
-use soroban_sdk::{
-    xdr::{ScErrorCode, ScErrorType},
-    BytesN, Env, Error, Vec,
-};
-use utils::{
-    multisig::{SignerSet, ThresholdSet},
-    testing_utils::assert_eq_event,
-};
-
-// Test vectors copied from `utils/src/tests/multisig.rs` so we can exercise success paths
-// through the macro-generated contract entrypoints.
-fn test_digest(env: &Env) -> BytesN<32> {
-    BytesN::from_array(
-        env,
-        &[
-            0x7d, 0x84, 0xfd, 0x50, 0x8a, 0x27, 0xac, 0x81, 0xde, 0xe4, 0xbf, 0xa9, 0x7f, 0x29, 0xbe, 0xdb, 0x88, 0x5c,
-            0x1b, 0xd7, 0xfc, 0x46, 0x50, 0xf4, 0x91, 0xe6, 0x4f, 0xbd, 0xaa, 0x05, 0xcd, 0xac,
-        ],
-    )
-}
-
-// Signer 1: 0x9b6ababd080456f900ed64e74d122ff9ca40daa1
-fn test_signer1(env: &Env) -> BytesN<20> {
-    BytesN::from_array(
-        env,
-        &[
-            0x9b, 0x6a, 0xba, 0xbd, 0x08, 0x04, 0x56, 0xf9, 0x00, 0xed, 0x64, 0xe7, 0x4d, 0x12, 0x2f, 0xf9, 0xca, 0x40,
-            0xda, 0xa1,
-        ],
-    )
-}
-
-// Signer 2: 0xd6869dacf9c6ce629cf042864737690641d0e2d7
-fn test_signer2(env: &Env) -> BytesN<20> {
-    BytesN::from_array(
-        env,
-        &[
-            0xd6, 0x86, 0x9d, 0xac, 0xf9, 0xc6, 0xce, 0x62, 0x9c, 0xf0, 0x42, 0x86, 0x47, 0x37, 0x69, 0x06, 0x41, 0xd0,
-            0xe2, 0xd7,
-        ],
-    )
-}
-
-// Signature from signer1 for test_digest
-fn test_sig1(env: &Env) -> BytesN<65> {
-    BytesN::from_array(
-        env,
-        &[
-            0x31, 0x53, 0x7d, 0xcf, 0xe1, 0xec, 0x4d, 0x7e, 0x89, 0xf5, 0x97, 0x2c, 0xcd, 0x30, 0x65, 0xe3, 0x4e, 0x17,
-            0x8e, 0x30, 0x2c, 0x1b, 0x9e, 0x8e, 0x17, 0x5d, 0x38, 0x43, 0xa2, 0x96, 0x4f, 0x28, // r
-            0x63, 0xf2, 0xb6, 0x0c, 0x7e, 0xf7, 0x43, 0x63, 0xb6, 0x87, 0xf8, 0x22, 0xdb, 0x6c, 0x31, 0x3e, 0x87, 0x62,
-            0xb3, 0x8d, 0x30, 0x97, 0xb6, 0xfe, 0xc9, 0xb7, 0xb7, 0x61, 0x65, 0x63, 0x0a, 0xaa, // s
-            0x1b, // v = 27
-        ],
-    )
-}
-
-// Signature from signer2 for test_digest
-fn test_sig2(env: &Env) -> BytesN<65> {
-    BytesN::from_array(
-        env,
-        &[
-            0x42, 0x67, 0x4f, 0xc6, 0x30, 0xe3, 0x2f, 0x90, 0x00, 0xbc, 0x95, 0x27, 0x1e, 0xc5, 0x42, 0x83, 0xc8, 0xad,
-            0x35, 0x00, 0x16, 0xbb, 0x66, 0xa1, 0x84, 0x64, 0x95, 0x89, 0x63, 0xa5, 0x1f, 0x03, // r
-            0x14, 0x6e, 0x8b, 0x3f, 0xbb, 0x3a, 0x5b, 0xd0, 0xb8, 0x9d, 0x3b, 0x6c, 0x1e, 0x01, 0xdd, 0x61, 0x4e, 0x86,
-            0xba, 0xe0, 0x13, 0x51, 0xdc, 0x3d, 0x1f, 0xfe, 0x35, 0x22, 0xc8, 0x3e, 0xd4, 0x50, // s
-            0x1c, // v = 28
-        ],
-    )
-}
-
-#[test]
-fn set_signer_requires_auth() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-    let signer = BytesN::<20>::from_array(&env, &[1u8; 20]);
-
-    // No auth provided -> should fail.
-    let res = client.try_set_signer(&signer, &true);
-    assert_eq!(res.unwrap_err().unwrap(), Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction));
-}
-
-#[test]
-fn set_threshold_requires_auth() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // No auth provided -> should fail (auth happens before any threshold validation).
-    let res = client.try_set_threshold(&1);
-    assert_eq!(res.unwrap_err().unwrap(), Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction));
-}
-
-#[test]
-fn set_signer_and_threshold_work_with_auth() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let signer = BytesN::<20>::from_array(&env, &[1u8; 20]);
-
-    // These must be exported contract entrypoints via the macro-generated contractimpl(contracttrait).
-    client.set_signer(&signer, &true);
-    assert_eq_event(&env, &contract_id, SignerSet { signer: signer.clone(), active: true });
-
-    client.set_threshold(&1);
-    assert_eq_event(&env, &contract_id, ThresholdSet { threshold: 1 });
-
-    assert!(client.is_signer(&signer));
-    assert_eq!(client.total_signers(), 1);
-    assert_eq!(client.threshold(), 1);
-
-    // Cannot set threshold higher than total signers.
-    let res = client.try_set_threshold(&2);
-    assert_eq!(res.err().unwrap().ok().unwrap(), utils::errors::MultiSigError::TotalSignersLessThanThreshold.into());
-    // Threshold should remain unchanged.
-    assert_eq!(client.threshold(), 1);
-}
-
-#[test]
-fn set_signer_remove_path_works() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let signer = BytesN::<20>::from_array(&env, &[1u8; 20]);
-    client.set_signer(&signer, &true);
-    assert_eq_event(&env, &contract_id, SignerSet { signer: signer.clone(), active: true });
-    assert!(client.is_signer(&signer));
-    assert_eq!(client.total_signers(), 1);
-
-    // active=false branch should remove the signer.
-    client.set_signer(&signer, &false);
-    assert_eq_event(&env, &contract_id, SignerSet { signer: signer.clone(), active: false });
-    assert!(!client.is_signer(&signer));
-    assert_eq!(client.total_signers(), 0);
-}
-
-#[test]
-fn verify_signatures_rejects_zero_threshold_by_default() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // Default threshold is 0 (from storage default), so verify should error with ZeroThreshold.
-    let digest = BytesN::<32>::from_array(&env, &[9u8; 32]);
-    let sigs = Vec::<BytesN<65>>::new(&env);
-
-    let result = client.try_verify_signatures(&digest, &sigs);
-    assert_eq!(result.err().unwrap().ok().unwrap(), utils::errors::MultiSigError::ZeroThreshold.into());
-}
-
-#[test]
-fn verify_n_signatures_rejects_insufficient_signatures() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let digest = BytesN::<32>::from_array(&env, &[8u8; 32]);
-    let sigs = Vec::<BytesN<65>>::new(&env);
-
-    // threshold=1 but 0 signatures => SignatureError
-    let result = client.try_verify_n_signatures(&digest, &sigs, &1);
-    assert_eq!(result.err().unwrap().ok().unwrap(), utils::errors::MultiSigError::SignatureError.into());
-
-    // threshold=1 with a valid signature but no registered signers => SignerNotFound
-    let digest = test_digest(&env);
-    let sigs = Vec::from_array(&env, [test_sig1(&env)]);
-    let result = client.try_verify_n_signatures(&digest, &sigs, &1);
-    assert_eq!(result.err().unwrap().ok().unwrap(), utils::errors::MultiSigError::SignerNotFound.into());
-}
-
-#[test]
-fn verify_signatures_success() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // Configure signers + threshold=2 using macro-exported entrypoints.
-    let s1 = test_signer1(&env);
-    let s2 = test_signer2(&env);
-    client.set_signer(&s1, &true);
-    client.set_signer(&s2, &true);
-    client.set_threshold(&2);
-
-    let digest = test_digest(&env);
-    // Must be sorted by signer address (s1 < s2).
-    let sigs = Vec::from_array(&env, [test_sig1(&env), test_sig2(&env)]);
-    client.verify_signatures(&digest, &sigs);
-
-    // Unsorted signatures should be rejected.
-    let unsorted = Vec::from_array(&env, [test_sig2(&env), test_sig1(&env)]);
-    let result = client.try_verify_signatures(&digest, &unsorted);
-    assert_eq!(result.err().unwrap().ok().unwrap(), utils::errors::MultiSigError::UnsortedSigners.into());
-}
-
-#[test]
-fn verify_n_signatures_success() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // Configure signers (threshold stored is irrelevant for verify_n_signatures).
-    let s1 = test_signer1(&env);
-    let s2 = test_signer2(&env);
-    client.set_signer(&s1, &true);
-    client.set_signer(&s2, &true);
-    client.set_threshold(&2);
-
-    let digest = test_digest(&env);
-    let sigs = Vec::from_array(&env, [test_sig1(&env), test_sig2(&env)]);
-    client.verify_n_signatures(&digest, &sigs, &1);
-}
-
-#[test]
-fn set_signer_rejects_zero_address() {
-    let env = Env::default();
-    env.mock_all_auths();
-
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let zero = BytesN::<20>::from_array(&env, &[0u8; 20]);
-    let res = client.try_set_signer(&zero, &true);
-    assert_eq!(res.err().unwrap().ok().unwrap(), utils::errors::MultiSigError::InvalidSigner.into());
-}

package/contracts/macro-integration-tests/tests/runtime/multisig/mod.rs

@@ -1,9 +0,0 @@
-use soroban_sdk::contract;
-
-mod admin_entrypoints;
-mod self_auth;
-
-/// Shared contract used by multisig runtime tests.
-#[contract]
-#[common_macros::multisig]
-pub struct TestContract;

package/contracts/macro-integration-tests/tests/runtime/multisig/self_auth.rs

@@ -1,54 +0,0 @@
-// Runtime tests: `#[multisig]` self-owning authorization behavior.
-//
-// Tests covered:
-// - `Auth::authorizer()` resolves to the contract's own address.
-// - MultiSig mutation calls can be authorized by the contract address (self-owning pattern).
-
-use super::{TestContract, TestContractClient};
-use soroban_sdk::{BytesN, Env, Vec};
-use utils::{
-    multisig::{SignerSet, ThresholdSet},
-    testing_utils::assert_contains_events,
-};
-
-#[test]
-fn authorizer_is_current_contract_address() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let expected = env.as_contract(&contract_id, || env.current_contract_address());
-    let got = client.authorizer();
-    assert_eq!(got, Some(expected));
-}
-
-#[test]
-fn self_auth_allows_multisig_admin_calls() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    // Seed multisig storage directly, then verify view methods are wired via the macro-generated
-    // `MultiSig` trait impl.
-    let signer = BytesN::<20>::from_array(&env, &[1u8; 20]);
-    let mut signers = Vec::<BytesN<20>>::new(&env);
-    signers.push_back(signer.clone());
-    env.as_contract(&contract_id, || {
-        utils::multisig::init_multisig(&env, &signers, 1);
-    });
-
-    assert_contains_events(
-        &env,
-        &contract_id,
-        &[&SignerSet { signer: signer.clone(), active: true }, &ThresholdSet { threshold: 1 }],
-    );
-
-    // Verify stored state through view calls.
-    assert_eq!(client.threshold(), 1);
-    assert!(client.is_signer(&signer));
-    assert_eq!(client.total_signers(), 1);
-
-    let signers: Vec<BytesN<20>> = client.get_signers();
-    assert_eq!(signers.len(), 1);
-    assert_eq!(signers.get(0).unwrap(), signer);
-}

package/contracts/macro-integration-tests/tests/runtime/oapp/mod.rs

@@ -1,46 +0,0 @@
-use endpoint_v2::Origin;
-use oapp::oapp_receiver::LzReceiveInternal;
-use oapp_macros::oapp;
-use soroban_sdk::{contractimpl, symbol_short, Address, Bytes, BytesN, Env};
-
-mod oapp_core;
-mod options_type3;
-mod receiver;
-mod sender;
-
-/// Shared contract used by oapp-macros runtime tests.
-///
-/// Notes:
-/// - `#[oapp]` generates only trait impls. User must apply `#[lz_contract]` (or similar) for contract + TTL + Auth.
-/// - Default trait impls: `OAppCore`, `OAppReceiver`, `OAppOptionsType3`, `OAppSenderInternal`
-#[oapp]
-#[common_macros::lz_contract]
-pub struct TestOApp;
-
-impl LzReceiveInternal for TestOApp {
-    fn __lz_receive(
-        env: &Env,
-        _origin: &Origin,
-        _guid: &BytesN<32>,
-        _message: &Bytes,
-        _extra_data: &Bytes,
-        _executor: &Address,
-        _value: i128,
-    ) {
-        // Mark that the internal handler was invoked.
-        env.storage().instance().set(&symbol_short!("lzr_c"), &true);
-    }
-}
-
-#[contractimpl]
-impl TestOApp {
-    /// Initializes owner and stores an endpoint address for `OAppCore::endpoint`.
-    pub fn init(env: Env, owner: Address, endpoint: Address) {
-        Self::init_owner(&env, &owner);
-        oapp::oapp_core::OAppCoreStorage::set_endpoint(&env, &endpoint);
-    }
-
-    pub fn lz_receive_called(env: Env) -> bool {
-        env.storage().instance().get(&symbol_short!("lzr_c")).unwrap_or(false)
-    }
-}

package/contracts/macro-integration-tests/tests/runtime/oapp/oapp_core.rs

@@ -1,170 +0,0 @@
-// Runtime tests: OAppCore behavior generated by `#[oapp]`.
-
-use super::{TestOApp, TestOAppClient};
-use oapp::oapp_core::{OAppCoreStorage, PeerSet};
-use soroban_sdk::{
-    contract, contractimpl,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    xdr::{ScErrorCode, ScErrorType},
-    Address, BytesN, Env, Error, IntoVal,
-};
-use utils::testing_utils::assert_contains_event;
-
-/// Minimal endpoint stub used to verify `OAppCore::set_delegate` forwards calls.
-#[contract]
-pub struct MockEndpoint;
-
-#[contractimpl]
-impl MockEndpoint {
-    pub fn set_delegate(env: Env, oapp: Address, new_delegate: Option<Address>) {
-        if let Some(d) = new_delegate {
-            env.storage().instance().set(&oapp, &d);
-        } else {
-            env.storage().instance().remove(&oapp);
-        }
-    }
-
-    pub fn delegate(env: Env, oapp: Address) -> Option<Address> {
-        env.storage().instance().get(&oapp)
-    }
-}
-
-#[test]
-fn oapp_version_default() {
-    let env = Env::default();
-    let contract_id = env.register(TestOApp, ());
-    let client = TestOAppClient::new(&env, &contract_id);
-
-    // Default `OAppCore::oapp_version` should be callable without initialization.
-    assert_eq!(client.oapp_version(), (1u64, 1u64));
-}
-
-#[test]
-fn endpoint_roundtrip() {
-    let env = Env::default();
-    let contract_id = env.register(TestOApp, ());
-    let client = TestOAppClient::new(&env, &contract_id);
-
-    // Before init, `endpoint()` unwraps storage and should fail.
-    assert!(client.try_endpoint().is_err());
-
-    let owner = Address::generate(&env);
-    let endpoint = Address::generate(&env);
-    client.init(&owner, &endpoint);
-
-    assert_eq!(client.endpoint(), endpoint);
-}
-
-#[test]
-fn set_peer_requires_auth_and_updates_storage() {
-    let env = Env::default();
-    let contract_id = env.register(TestOApp, ());
-    let client = TestOAppClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    let endpoint = Address::generate(&env);
-    client.init(&owner, &endpoint);
-
-    let eid: u32 = 101;
-    let peer = Some(BytesN::<32>::from_array(&env, &[7u8; 32]));
-
-    // Peer is None when unset.
-    assert_eq!(client.peer(&eid), None);
-
-    // Unauthorized set should fail.
-    let unauthorized = client.try_set_peer(&eid, &peer, &owner);
-    assert_eq!(
-        unauthorized.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Authorized set should succeed.
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "set_peer",
-                args: (&eid, &peer, &owner).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .set_peer(&eid, &peer, &owner);
-
-    // Assert event before any other contract call (Soroban events are per-call).
-    assert_contains_event(&env, &contract_id, PeerSet { eid, peer: peer.clone() });
-
-    // Verify storage without issuing another contract call (so we don't clobber event log).
-    env.as_contract(&contract_id, || {
-        assert_eq!(OAppCoreStorage::peer(&env, eid), peer.clone());
-    });
-
-    // Remove peer by setting None.
-    let none: Option<BytesN<32>> = None;
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract_id,
-            fn_name: "set_peer",
-            args: (&eid, &none, &owner).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    client.set_peer(&eid, &none, &owner);
-    assert_contains_event(&env, &contract_id, PeerSet { eid, peer: None });
-    env.as_contract(&contract_id, || {
-        assert_eq!(OAppCoreStorage::peer(&env, eid), None);
-    });
-}
-
-#[test]
-fn set_delegate_requires_auth_and_updates_endpoint() {
-    let env = Env::default();
-    let contract_id = env.register(TestOApp, ());
-    let client = TestOAppClient::new(&env, &contract_id);
-
-    let endpoint_id = env.register(MockEndpoint, ());
-    let endpoint_client = MockEndpointClient::new(&env, &endpoint_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner, &endpoint_id);
-
-    // Unauthorized set should fail.
-    let delegate = Some(Address::generate(&env));
-    let unauthorized = client.try_set_delegate(&delegate, &owner);
-    assert_eq!(
-        unauthorized.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Authorized set should succeed and forward to the endpoint.
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "set_delegate",
-                args: (&delegate, &owner).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .set_delegate(&delegate, &owner);
-
-    assert_eq!(endpoint_client.delegate(&contract_id), delegate);
-
-    // Authorized removal should clear the endpoint delegate.
-    let none: Option<Address> = None;
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "set_delegate",
-                args: (&none, &owner).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .set_delegate(&none, &owner);
-
-    assert_eq!(endpoint_client.delegate(&contract_id), None);
-}

package/contracts/macro-integration-tests/tests/runtime/oapp/options_type3.rs

@@ -1,154 +0,0 @@
-// Runtime tests: OAppOptionsType3 defaults generated by `#[oapp]`.
-
-use super::{TestOApp, TestOAppClient};
-use oapp::oapp_options_type3::{EnforcedOptionParam, EnforcedOptionSet};
-use oapp::OAppError;
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    vec, Address, Bytes, Env, IntoVal,
-};
-use utils::testing_utils::assert_contains_event;
-
-const OPTION_TYPE_3: u16 = 3;
-const REMOTE_EID_1: u32 = 100;
-const MSG_TYPE_SEND: u32 = 1;
-const MSG_TYPE_RECEIVE: u32 = 2;
-
-fn create_valid_options(env: &Env, data: &[u8]) -> Bytes {
-    let mut buffer = Bytes::from_array(env, &OPTION_TYPE_3.to_be_bytes());
-    buffer.extend_from_slice(data);
-    buffer
-}
-
-#[test]
-fn enforced_options_lifecycle_and_auth() {
-    let env = Env::default();
-    let contract_id = env.register(TestOApp, ());
-    let client = TestOAppClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner, &Address::generate(&env));
-
-    // Unset returns None (storage default).
-    assert_eq!(client.enforced_options(&999, &999), None);
-
-    let enforced_1 = create_valid_options(&env, &[1, 2, 3, 4]);
-    let enforced_2 = create_valid_options(&env, &[5, 6, 7, 8]);
-    let params = vec![
-        &env,
-        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(enforced_1.clone()) },
-        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_RECEIVE, options: Some(enforced_2.clone()) },
-    ];
-
-    // Unauthorized set should fail (only_auth).
-    assert!(client.try_set_enforced_options(&params, &owner).is_err());
-
-    // Non-owner authorized should also fail.
-    let non_owner = Address::generate(&env);
-    env.mock_auths(&[MockAuth {
-        address: &non_owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract_id,
-            fn_name: "set_enforced_options",
-            args: (&params, &non_owner).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    assert!(client.try_set_enforced_options(&params, &non_owner).is_err());
-
-    // Owner-authorized set should succeed.
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract_id,
-            fn_name: "set_enforced_options",
-            args: (&params, &owner).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    client.set_enforced_options(&params, &owner);
-
-    assert_contains_event(&env, &contract_id, EnforcedOptionSet { enforced_options: params.clone() });
-
-    assert_eq!(client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), Some(enforced_1));
-    assert_eq!(client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_RECEIVE), Some(enforced_2));
-}
-
-#[test]
-fn set_enforced_options_rejects_invalid_option_type() {
-    let env = Env::default();
-    let contract_id = env.register(TestOApp, ());
-    let client = TestOAppClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner, &Address::generate(&env));
-
-    // wrong type header (not 3)
-    let mut invalid = Bytes::from_array(&env, &(4u16).to_be_bytes());
-    invalid.extend_from_slice(&[1, 2, 3]);
-
-    let 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: &contract_id,
-            fn_name: "set_enforced_options",
-            args: (&params, &owner).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    let result = client.try_set_enforced_options(&params, &owner);
-    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
-}
-
-#[test]
-fn combine_options_behavior_and_validation() {
-    let env = Env::default();
-    let contract_id = env.register(TestOApp, ());
-    let client = TestOAppClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    client.init(&owner, &Address::generate(&env));
-
-    // No enforced => returns extra (including empty).
-    let extra_only = create_valid_options(&env, &[9, 10, 11]);
-    assert_eq!(client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra_only), extra_only);
-    let empty_extra = Bytes::new(&env);
-    assert_eq!(client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &empty_extra), empty_extra);
-
-    // Set enforced for (eid, msg_type).
-    let enforced = create_valid_options(&env, &[1, 2, 3, 4]);
-    let params =
-        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(enforced.clone()) }];
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &contract_id,
-            fn_name: "set_enforced_options",
-            args: (&params, &owner).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    client.set_enforced_options(&params, &owner);
-
-    // Enforced present: empty extra => enforced.
-    assert_eq!(client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &Bytes::new(&env)), enforced.clone());
-
-    // Both present: enforced + extra(without its 2-byte header).
-    let extra = create_valid_options(&env, &[4, 5, 6]);
-    let combined = client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra);
-    let expected = create_valid_options(&env, &[1, 2, 3, 4, 4, 5, 6]);
-    assert_eq!(combined, expected);
-
-    // Extra has wrong type (len >= 2) => InvalidOptions.
-    let mut extra_invalid = Bytes::from_array(&env, &(4u16).to_be_bytes());
-    extra_invalid.extend_from_slice(&[9, 9, 9]);
-    let bad = client.try_combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra_invalid);
-    assert_eq!(bad.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
-
-    // Extra non-empty but too short (<2) => InvalidOptions.
-    let too_short = Bytes::from_array(&env, &[1u8]);
-    let bad2 = client.try_combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &too_short);
-    assert_eq!(bad2.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
-}