@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/endpoint-v2/src/tests/message_lib_manager/register_library.rs

@@ -1,117 +1,114 @@
+use soroban_sdk::{testutils::Address as _, vec, Address};
+use utils::testing_utils::assert_event;
+
 use crate::{
+    errors::EndpointError,
     events::LibraryRegistered,
     storage,
     tests::{
         endpoint_setup::setup,
-        mock::{MockMessageLib, MockValidMessageLib},
+        mock::{MockMessageLib, MockReceiver, MockValidMessageLib},
     },
 };
-use soroban_sdk::{testutils::Address as _, vec, Address};
-use utils::testing_utils::assert_event;
-
-use crate::errors::EndpointError;
 
+// Successful registration (state update + event emission)
 #[test]
 fn test_register_library() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    // mock a valid message lib
     let lib = env.register(MockValidMessageLib, ());
 
-    // Verify initial state - library count should be 0
-    let initial_count =
-        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::registered_library_count(env));
-    assert_eq!(initial_count, 0, "Initial library count should be 0");
-
-    // Mock owner auth for register_library
-    context.mock_owner_auth("register_library", (&lib,));
+    // Verify initial state via public interface.
+    assert_eq!(endpoint_client.registered_libraries_count(), 0);
+    assert!(!endpoint_client.is_registered_library(&lib));
 
-    endpoint_client.register_library(&lib);
+    context.register_library_with_auth(&lib);
 
-    // Assert event was published
+    // Verify event emission.
     assert_event(env, &endpoint_client.address, LibraryRegistered { new_lib: lib.clone() });
 
-    // Assert public interface methods work
+    // Verify state update via public interface.
     assert!(endpoint_client.is_registered_library(&lib));
+    assert_eq!(endpoint_client.registered_libraries_count(), 1);
 
     let libraries = endpoint_client.get_registered_libraries(&0, &1);
     assert_eq!(libraries, vec![&env, lib.clone()]);
 
-    // Assert storage changes directly
+    // Verify storage invariants (bidirectional index mapping).
     let lib_clone = lib.clone();
     env.as_contract(&endpoint_client.address, || {
-        // Verify library was assigned ID 0 (first library)
         let library_id = storage::EndpointStorage::library_to_index(env, &lib_clone);
-        assert_eq!(library_id, Some(0), "Library should be assigned ID 0");
+        assert_eq!(library_id, Some(0));
 
-        // Verify ID 0 maps back to the library
         let stored_lib = storage::EndpointStorage::index_to_library(env, 0);
-        assert_eq!(stored_lib, Some(lib_clone.clone()), "ID 0 should map to the registered library");
+        assert_eq!(stored_lib, Some(lib_clone.clone()));
 
-        // Verify library count was incremented
         let new_count = storage::EndpointStorage::registered_library_count(env);
-        assert_eq!(new_count, 1, "Library count should be incremented to 1");
+        assert_eq!(new_count, 1);
 
-        // Verify has_library_to_id returns true
         let has_library = storage::EndpointStorage::has_library_to_index(env, &lib_clone);
-        assert!(has_library, "has_library_to_id should return true for registered library");
+        assert!(has_library);
     });
 }
 
+// Duplicate registration rejection
 #[test]
 fn test_register_library_is_already_registered() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    // mock a valid message lib
     let lib = env.register(MockValidMessageLib, ());
 
-    // First registration with owner auth
-    context.mock_owner_auth("register_library", (&lib,));
-    endpoint_client.register_library(&lib);
+    context.register_library_with_auth(&lib);
 
-    // Try to register the same library again with owner auth
     context.mock_owner_auth("register_library", (&lib,));
     let result = endpoint_client.try_register_library(&lib);
-
     assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::AlreadyRegistered.into());
 }
 
+// Invalid library interface rejection (must implement message_lib_type)
 #[test]
 fn test_register_library_is_unsupported_interface() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    let random_lib_address = Address::generate(env);
+    // A contract that does NOT implement `message_lib_type()`.
+    let invalid_lib = env.register(MockReceiver, ());
 
-    // Mock owner auth for register_library
-    context.mock_owner_auth("register_library", (&random_lib_address,));
-
-    let result = endpoint_client.try_register_library(&random_lib_address);
+    // Must pass owner auth so this test actually exercises interface validation.
+    context.mock_owner_auth("register_library", (&invalid_lib,));
+    let result = endpoint_client.try_register_library(&invalid_lib);
     assert!(result.is_err());
+
+    // Verify no partial state updates.
+    assert_eq!(endpoint_client.registered_libraries_count(), 0);
+    assert!(!endpoint_client.is_registered_library(&invalid_lib));
+
+    // Verify no partial storage updates.
+    env.as_contract(&endpoint_client.address, || {
+        assert_eq!(storage::EndpointStorage::registered_library_count(env), 0);
+        assert_eq!(storage::EndpointStorage::library_to_index(env, &invalid_lib), None);
+        assert!(!storage::EndpointStorage::has_library_to_index(env, &invalid_lib));
+    });
 }
 
+// Authorization (only owner)
 #[test]
 fn test_register_library_owner_auth() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    // Deploy a mock message library contract
     let lib = env.register(MockMessageLib, ());
 
-    // Mock owner auth for register_library
-    context.mock_owner_auth("register_library", (&lib,));
-
-    // should succeed
-    endpoint_client.register_library(&lib);
+    context.register_library_with_auth(&lib);
 
     let library = endpoint_client.get_registered_libraries(&0, &1);
-    assert_eq!(library, vec![env, lib]);
+    assert_eq!(library, vec![&env, lib]);
 }
 
 #[test]
@@ -129,3 +126,28 @@ fn test_register_library_without_owner_auth() {
 
     endpoint_client.register_library(&lib);
 }
+
+// Sequential index assignment (storage invariants)
+#[test]
+fn test_register_multiple_libraries_assigns_sequential_indices_and_orders_results() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let lib0 = env.register(MockValidMessageLib, ());
+    let lib1 = env.register(MockValidMessageLib, ());
+
+    context.register_library_with_auth(&lib0);
+    context.register_library_with_auth(&lib1);
+
+    // storage invariants
+    let lib0c = lib0.clone();
+    let lib1c = lib1.clone();
+    env.as_contract(&endpoint_client.address, || {
+        assert_eq!(storage::EndpointStorage::registered_library_count(env), 2);
+        assert_eq!(storage::EndpointStorage::library_to_index(env, &lib0c), Some(0));
+        assert_eq!(storage::EndpointStorage::library_to_index(env, &lib1c), Some(1));
+        assert_eq!(storage::EndpointStorage::index_to_library(env, 0), Some(lib0c));
+        assert_eq!(storage::EndpointStorage::index_to_library(env, 1), Some(lib1c));
+    });
+}

package/contracts/endpoint-v2/src/tests/message_lib_manager/registered_libraries_count.rs

@@ -0,0 +1,42 @@
+use crate::tests::{endpoint_setup::setup, mock::MockValidMessageLib};
+
+// The registered_libraries_count increments after successful registrations
+#[test]
+fn test_registered_libraries_count_increments_with_registrations() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let lib0 = env.register(MockValidMessageLib, ());
+    let lib1 = env.register(MockValidMessageLib, ());
+    let lib2 = env.register(MockValidMessageLib, ());
+
+    assert_eq!(endpoint_client.registered_libraries_count(), 0);
+
+    context.register_library_with_auth(&lib0);
+    assert_eq!(endpoint_client.registered_libraries_count(), 1);
+
+    context.register_library_with_auth(&lib1);
+    assert_eq!(endpoint_client.registered_libraries_count(), 2);
+
+    context.register_library_with_auth(&lib2);
+    assert_eq!(endpoint_client.registered_libraries_count(), 3);
+}
+
+// Failed registration does not change registered_libraries_count
+#[test]
+fn test_registered_libraries_count_unchanged_on_duplicate_registration() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let lib = env.register(MockValidMessageLib, ());
+    context.register_library_with_auth(&lib);
+    assert_eq!(endpoint_client.registered_libraries_count(), 1);
+
+    // Duplicate registration should fail and not change count.
+    context.mock_owner_auth("register_library", (&lib,));
+    let result = endpoint_client.try_register_library(&lib);
+    assert!(result.is_err());
+    assert_eq!(endpoint_client.registered_libraries_count(), 1);
+}

package/contracts/endpoint-v2/src/tests/message_lib_manager/require_receive_lib_for_eid.rs

@@ -0,0 +1,61 @@
+use soroban_sdk::vec;
+
+use crate::{tests::endpoint_setup::setup, EndpointV2, MessageLibType};
+
+// The require_receive_lib_for_eid internal validation (registered + type + supported_eid)
+#[test]
+#[should_panic(expected = "Error(Contract, #16)")] // EndpointError::OnlyRegisteredLib
+fn test_require_receive_lib_for_eid_unregistered_lib() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid(env, &lib, context.eid));
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #15)")] // EndpointError::OnlyReceiveLib
+fn test_require_receive_lib_for_eid_wrong_lib_type() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&lib);
+
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid(env, &lib, context.eid));
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #23)")] // EndpointError::UnsupportedEid
+fn test_require_receive_lib_for_eid_unsupported_eid() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let unsupported_eid = context.eid + 1;
+    let lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+    context.register_library_with_auth(&lib);
+
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_receive_lib_for_eid(env, &lib, unsupported_eid));
+}
+
+#[test]
+fn test_require_receive_lib_for_eid_success_for_receive_and_send_and_receive() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+    context.register_library_with_auth(&receive_lib);
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_receive_lib_for_eid(env, &receive_lib, context.eid)
+    });
+
+    let send_and_receive = context.setup_mock_message_lib(MessageLibType::SendAndReceive, vec![env, context.eid]);
+    context.register_library_with_auth(&send_and_receive);
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_receive_lib_for_eid(env, &send_and_receive, context.eid)
+    });
+}

package/contracts/endpoint-v2/src/tests/message_lib_manager/require_registered.rs

@@ -1,13 +1,14 @@
+use soroban_sdk::{testutils::Address as _, Address};
+
 use crate::{
     tests::{endpoint_setup::setup, mock::MockValidMessageLib},
     EndpointV2,
 };
-use soroban_sdk::{testutils::Address as _, Address};
 
 // Unit tests for require functions
 
 #[test]
-#[should_panic(expected = "Error(Contract, #15)")] // EndpointError::OnlyRegisteredLib
+#[should_panic(expected = "Error(Contract, #16)")] // EndpointError::OnlyRegisteredLib
 fn test_require_registered_with_unregistered_lib() {
     let context = setup();
     let env = &context.env;
@@ -25,10 +26,7 @@ fn test_require_registered_with_registered_lib() {
 
     // Register a valid message lib
     let lib = env.register(MockValidMessageLib, ());
-
-    // Mock owner auth for register_library
-    context.mock_owner_auth("register_library", (&lib,));
-    endpoint_client.register_library(&lib);
+    context.register_library_with_auth(&lib);
 
     // Should not panic
     env.as_contract(&endpoint_client.address, || EndpointV2::require_registered(env, &lib));

package/contracts/endpoint-v2/src/tests/message_lib_manager/require_send_lib_for_eid.rs

@@ -0,0 +1,59 @@
+use soroban_sdk::vec;
+
+use crate::{tests::endpoint_setup::setup, EndpointV2, MessageLibType};
+
+// The require_send_lib_for_eid internal validation (registered + type + supported_eid)
+#[test]
+#[should_panic(expected = "Error(Contract, #16)")] // EndpointError::OnlyRegisteredLib
+fn test_require_send_lib_for_eid_unregistered_lib() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid(env, &lib, context.eid));
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #17)")] // EndpointError::OnlySendLib
+fn test_require_send_lib_for_eid_wrong_lib_type() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+    context.register_library_with_auth(&lib);
+
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid(env, &lib, context.eid));
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #23)")] // EndpointError::UnsupportedEid
+fn test_require_send_lib_for_eid_unsupported_eid() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let unsupported_eid = context.eid + 1;
+    let lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&lib);
+
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid(env, &lib, unsupported_eid));
+}
+
+#[test]
+fn test_require_send_lib_for_eid_success_for_send_and_send_and_receive() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&send_lib);
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_send_lib_for_eid(env, &send_lib, context.eid));
+
+    let send_and_receive = context.setup_mock_message_lib(MessageLibType::SendAndReceive, vec![env, context.eid]);
+    context.register_library_with_auth(&send_and_receive);
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_send_lib_for_eid(env, &send_and_receive, context.eid)
+    });
+}

package/contracts/endpoint-v2/src/tests/message_lib_manager/require_supported_eid.rs

@@ -1,8 +1,21 @@
-use crate::{tests::endpoint_setup::setup, EndpointV2, MessageLibType};
 use soroban_sdk::{testutils::Address as _, vec, Address};
 
+use crate::{tests::endpoint_setup::setup, EndpointV2, MessageLibType};
+
+// The require_supported_eid passes when the library supports the EID
+#[test]
+fn test_require_supported_eid_with_supported() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_supported_eid(env, &send_lib, context.eid));
+}
+
+// The require_supported_eid rejects when the library does not support the EID
 #[test]
-#[should_panic(expected = "Error(Contract, #22)")] // EndpointError::UnsupportedEid
+#[should_panic(expected = "Error(Contract, #23)")] // EndpointError::UnsupportedEid
 fn test_require_supported_eid_with_unsupported() {
     let context = setup();
     let env = &context.env;
@@ -13,6 +26,7 @@ fn test_require_supported_eid_with_unsupported() {
     env.as_contract(&endpoint_client.address, || EndpointV2::require_supported_eid(env, &send_lib, unsupported_eid));
 }
 
+// The require_supported_eid panics if the library address has no deployed contract
 #[test]
 #[should_panic(expected = "trying to get non-existing value for contract instance")]
 fn test_require_supported_eid_with_non_deployed_lib() {

package/contracts/endpoint-v2/src/tests/message_lib_manager/set_config.rs

@@ -1,45 +1,44 @@
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    vec, Address, IntoVal, Vec,
-};
+use soroban_sdk::{testutils::Address as _, vec, Address, Bytes, Vec};
 
-use crate::{tests::endpoint_setup::setup, SetConfigParam};
+use crate::{errors::EndpointError, tests::endpoint_setup::setup, tests::endpoint_setup::TestSetup, SetConfigParam};
 
-// Tests for set_config
-// Note: set_config is a pass-through method that delegates to MessageLibClient.
-// Since mock message libs don't implement set_config, we focus on testing authorization.
-// The actual config setting is tested in the message library contract tests.
+// Helpers
+fn set_config_with_auth(
+    context: &TestSetup,
+    caller: &Address,
+    oapp: &Address,
+    message_lib: &Address,
+    params: &Vec<SetConfigParam>,
+) {
+    context.mock_auth(caller, "set_config", (caller, oapp, message_lib, params));
+    context.endpoint_client.set_config(caller, oapp, message_lib, params);
+}
 
+// Authorization (caller == oapp)
 #[test]
-fn test_set_config_oapp_auth() {
+fn test_set_config_allows_oapp() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
     let oapp = Address::generate(env);
-    let message_lib = Address::generate(env); // Just use an address, won't actually call it
+    let message_lib = context.setup_mock_message_lib(crate::MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&message_lib);
 
-    let params: Vec<SetConfigParam> = vec![env];
+    let cfg = Bytes::from_slice(env, &[0x01, 0x02, 0x03]);
+    let params: Vec<SetConfigParam> =
+        vec![env, SetConfigParam { eid: context.eid, config_type: 1, config: cfg.clone() }];
 
-    // Try with oapp auth - should pass authorization check
-    // (will fail on lib call since it's not a real lib, but that's after auth)
-    env.mock_auths(&[MockAuth {
-        address: &oapp,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "set_config",
-            args: (&oapp, &oapp, &message_lib, &params).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    // Call will fail at library invocation, but we verify auth works
-    let _ = endpoint_client.try_set_config(&oapp, &oapp, &message_lib, &params);
-    // We're just verifying the auth part - the library call failure is expected
+    set_config_with_auth(&context, &oapp, &oapp, &message_lib, &params);
+
+    // Assert config persisted in the message lib via endpoint's get_config passthrough.
+    let stored = endpoint_client.get_config(&oapp, &message_lib, &context.eid, &1u32);
+    assert_eq!(stored, cfg);
 }
 
+// Authorization (caller == delegate(oapp))
 #[test]
-fn test_set_config_delegate_auth() {
+fn test_set_config_allows_delegate() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
@@ -47,33 +46,138 @@ fn test_set_config_delegate_auth() {
     let oapp = Address::generate(env);
     let delegate = Address::generate(env);
 
-    // Set delegate for oapp
+    // Set delegate for the OApp.
     let delegate_option = Some(delegate.clone());
-    env.mock_auths(&[MockAuth {
-        address: &oapp,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "set_delegate",
-            args: (&oapp, &delegate_option).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+    context.mock_auth(&oapp, "set_delegate", (&oapp, &delegate_option));
     endpoint_client.set_delegate(&oapp, &delegate_option);
 
+    let message_lib = context.setup_mock_message_lib(crate::MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&message_lib);
+    let cfg = Bytes::from_slice(env, &[0xAA, 0xBB, 0xCC, 0xDD]);
+    let params: Vec<SetConfigParam> =
+        vec![env, SetConfigParam { eid: context.eid, config_type: 2, config: cfg.clone() }];
+
+    set_config_with_auth(&context, &delegate, &oapp, &message_lib, &params);
+
+    // Assert config persisted in the message lib via endpoint's get_config passthrough.
+    let stored = endpoint_client.get_config(&oapp, &message_lib, &context.eid, &2u32);
+    assert_eq!(stored, cfg);
+}
+
+// Unauthorized caller is rejected
+#[test]
+fn test_set_config_unauthorized() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let unauthorized = Address::generate(env);
     let message_lib = Address::generate(env);
     let params: Vec<SetConfigParam> = vec![env];
 
-    // Try with delegate auth - should pass authorization check
-    env.mock_auths(&[MockAuth {
-        address: &delegate,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "set_config",
-            args: (&delegate, &oapp, &message_lib, &params).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    // Call will fail at library invocation, but we verify delegate auth works
-    let _ = endpoint_client.try_set_config(&delegate, &oapp, &message_lib, &params);
+    // Unauthorized should fail before `require_auth()`, so no mock_auth needed.
+    let result = endpoint_client.try_set_config(&unauthorized, &oapp, &message_lib, &params);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::Unauthorized.into());
+}
+
+// Library must be registered
+#[test]
+fn test_set_config_requires_registered_library() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let unregistered_lib = Address::generate(env);
+    let params: Vec<SetConfigParam> = vec![env];
+
+    // caller == oapp so it passes oapp auth, but should fail `require_registered`.
+    context.mock_auth(&oapp, "set_config", (&oapp, &oapp, &unregistered_lib, &params));
+    let result = endpoint_client.try_set_config(&oapp, &oapp, &unregistered_lib, &params);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlyRegisteredLib.into());
+}
+
+// Multiple params are persisted independently (keyed by eid + config_type)
+#[test]
+fn test_set_config_multiple_params_persists_each() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let message_lib = context.setup_mock_message_lib(crate::MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&message_lib);
+
+    let cfg_a = Bytes::from_slice(env, &[0x10, 0x11]);
+    let cfg_b = Bytes::from_slice(env, &[0x20, 0x21, 0x22]);
+    let cfg_c = Bytes::from_slice(env, &[0x30]);
+
+    let params: Vec<SetConfigParam> = vec![
+        env,
+        SetConfigParam { eid: context.eid, config_type: 7, config: cfg_a.clone() },
+        // Same eid, different config_type (should be independent).
+        SetConfigParam { eid: context.eid, config_type: 8, config: cfg_c.clone() },
+        // Different eid (should be independent).
+        SetConfigParam { eid: context.eid + 1, config_type: 8, config: cfg_b.clone() },
+    ];
+
+    set_config_with_auth(&context, &oapp, &oapp, &message_lib, &params);
+
+    let stored_a = endpoint_client.get_config(&oapp, &message_lib, &context.eid, &7u32);
+    let stored_c = endpoint_client.get_config(&oapp, &message_lib, &context.eid, &8u32);
+    let stored_b = endpoint_client.get_config(&oapp, &message_lib, &(context.eid + 1), &8u32);
+    assert_eq!(stored_a, cfg_a);
+    assert_eq!(stored_c, cfg_c);
+    assert_eq!(stored_b, cfg_b);
+}
+
+// The set_config overwrites existing config for the same key
+#[test]
+fn test_set_config_overwrites_existing_config() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let message_lib = context.setup_mock_message_lib(crate::MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&message_lib);
+
+    let cfg_v1 = Bytes::from_slice(env, &[0x01]);
+    let cfg_v2 = Bytes::from_slice(env, &[0x02, 0x03]);
+
+    let params_v1: Vec<SetConfigParam> =
+        vec![env, SetConfigParam { eid: context.eid, config_type: 9, config: cfg_v1.clone() }];
+    set_config_with_auth(&context, &oapp, &oapp, &message_lib, &params_v1);
+    assert_eq!(endpoint_client.get_config(&oapp, &message_lib, &context.eid, &9u32), cfg_v1);
+
+    let params_v2: Vec<SetConfigParam> =
+        vec![env, SetConfigParam { eid: context.eid, config_type: 9, config: cfg_v2.clone() }];
+    set_config_with_auth(&context, &oapp, &oapp, &message_lib, &params_v2);
+    assert_eq!(endpoint_client.get_config(&oapp, &message_lib, &context.eid, &9u32), cfg_v2);
+}
+
+// Config is isolated per OApp
+#[test]
+fn test_set_config_isolated_per_oapp() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp_a = Address::generate(env);
+    let oapp_b = Address::generate(env);
+
+    let message_lib = context.setup_mock_message_lib(crate::MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&message_lib);
+
+    let cfg_a = Bytes::from_slice(env, &[0xAA]);
+    let params: Vec<SetConfigParam> =
+        vec![env, SetConfigParam { eid: context.eid, config_type: 42, config: cfg_a.clone() }];
+
+    set_config_with_auth(&context, &oapp_a, &oapp_a, &message_lib, &params);
+
+    // OApp A sees its config.
+    assert_eq!(endpoint_client.get_config(&oapp_a, &message_lib, &context.eid, &42u32), cfg_a);
+    // OApp B should not see OApp A's config.
+    assert_eq!(endpoint_client.get_config(&oapp_b, &message_lib, &context.eid, &42u32), Bytes::new(env));
 }