@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

package/contracts/endpoint-v2/src/tests/endpoint_v2/verify.rs

@@ -1,17 +1,27 @@
-use crate::util::build_payload;
+use soroban_sdk::{vec, Bytes, BytesN, Env};
+use utils::testing_utils::assert_event;
+
 use crate::{
+    errors::EndpointError,
     events::PacketVerified,
-    storage,
-    tests::{endpoint_setup::setup, mock::MockReceiver},
+    tests::{
+        endpoint_setup::setup,
+        mock::{MockReceiver, MockReceiverReject},
+    },
+    util::build_payload,
     util::keccak256,
     Origin,
 };
-use soroban_sdk::{
-    testutils::{MockAuth, MockAuthInvoke},
-    vec, Bytes, BytesN, IntoVal,
-};
-use utils::testing_utils::assert_event;
 
+// Helpers
+fn default_payload_hash(env: &Env) -> BytesN<32> {
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let payload = build_payload(env, &guid, &message);
+    keccak256(env, &payload)
+}
+
+// Happy Path
 #[test]
 fn test_verify_success() {
     let context = setup();
@@ -24,36 +34,19 @@ fn test_verify_success() {
     let nonce = 1u64;
 
     // Setup receive library
-    let receive_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
-    context.mock_owner_auth("register_library", (&receive_lib,));
-    endpoint_client.register_library(&receive_lib);
-    context.mock_owner_auth("set_default_receive_library", (&src_eid, &receive_lib, &0u64));
-    endpoint_client.set_default_receive_library(&src_eid, &receive_lib, &0);
+    let receive_lib = context.setup_default_receive_lib(src_eid, 0);
 
     // Create payload hash
-    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
-    let guid = BytesN::from_array(env, &[5u8; 32]);
-    let payload = build_payload(env, &guid, &message);
-    let payload_hash = keccak256(env, &payload);
+    let payload_hash = default_payload_hash(env);
 
     let origin = Origin { src_eid, sender: sender.clone(), nonce };
 
     // Verify initial state - inbound payload hash should not exist
-    let initial_hash = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
-    });
+    let initial_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
     assert_eq!(initial_hash, None, "Initial inbound payload hash should be None");
 
     // Mock auth for receive_lib
-    env.mock_auths(&[MockAuth {
-        address: &receive_lib,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "verify",
-            args: (&receive_lib, &origin, &receiver, &payload_hash).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+    context.mock_auth(&receive_lib, "verify", (&receive_lib, &origin, &receiver, &payload_hash));
 
     endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash);
 
@@ -67,14 +60,9 @@ fn test_verify_success() {
     // Verify inbound payload hash was stored via public interface
     let stored_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
     assert_eq!(stored_hash, Some(payload_hash.clone()));
-
-    // Assert storage change directly
-    let stored_hash_direct = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
-    });
-    assert_eq!(stored_hash_direct, Some(payload_hash), "Storage should contain the inbound payload hash");
 }
 
+// Storage & Nonce Behavior
 #[test]
 fn test_verify_stores_payload_hash() {
     let context = setup();
@@ -87,30 +75,15 @@ fn test_verify_stores_payload_hash() {
     let nonce = 1u64;
 
     // Setup receive library
-    let receive_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
-    context.mock_owner_auth("register_library", (&receive_lib,));
-    endpoint_client.register_library(&receive_lib);
-    context.mock_owner_auth("set_default_receive_library", (&src_eid, &receive_lib, &0u64));
-    endpoint_client.set_default_receive_library(&src_eid, &receive_lib, &0);
+    let receive_lib = context.setup_default_receive_lib(src_eid, 0);
 
     // Create payload hash
-    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
-    let guid = BytesN::from_array(env, &[5u8; 32]);
-    let payload = build_payload(env, &guid, &message);
-    let payload_hash = keccak256(env, &payload);
+    let payload_hash = default_payload_hash(env);
 
     let origin = Origin { src_eid, sender: sender.clone(), nonce };
 
     // Mock auth for receive_lib
-    env.mock_auths(&[MockAuth {
-        address: &receive_lib,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "verify",
-            args: (&receive_lib, &origin, &receiver, &payload_hash).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+    context.mock_auth(&receive_lib, "verify", (&receive_lib, &origin, &receiver, &payload_hash));
 
     endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash);
 
@@ -119,6 +92,35 @@ fn test_verify_stores_payload_hash() {
     assert_eq!(stored_hash, Some(payload_hash));
 }
 
+#[test]
+fn test_verify_overwrites_payload_hash_for_same_nonce() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let receiver = env.register(MockReceiver, ());
+    let nonce = 1u64;
+
+    // Setup receive library
+    let receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    let origin = Origin { src_eid, sender: sender.clone(), nonce };
+
+    // Verify once
+    let payload_hash1 = BytesN::from_array(env, &[0x11u8; 32]);
+    context.mock_auth(&receive_lib, "verify", (&receive_lib, &origin, &receiver, &payload_hash1));
+    endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash1);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), Some(payload_hash1.clone()));
+
+    // Verify again with a different payload hash (current logic allows overwriting)
+    let payload_hash2 = BytesN::from_array(env, &[0x22u8; 32]);
+    context.mock_auth(&receive_lib, "verify", (&receive_lib, &origin, &receiver, &payload_hash2));
+    endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash2);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), Some(payload_hash2));
+}
+
 #[test]
 fn test_verify_multiple_nonces() {
     let context = setup();
@@ -130,38 +132,18 @@ fn test_verify_multiple_nonces() {
     let receiver = env.register(MockReceiver, ());
 
     // Setup receive library
-    let receive_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
-    context.mock_owner_auth("register_library", (&receive_lib,));
-    endpoint_client.register_library(&receive_lib);
-    context.mock_owner_auth("set_default_receive_library", (&src_eid, &receive_lib, &0u64));
-    endpoint_client.set_default_receive_library(&src_eid, &receive_lib, &0);
+    let receive_lib = context.setup_default_receive_lib(src_eid, 0);
 
     // Verify nonce 1
     let payload_hash1 = BytesN::from_array(env, &[1u8; 32]);
     let origin1 = Origin { src_eid, sender: sender.clone(), nonce: 1 };
-    env.mock_auths(&[MockAuth {
-        address: &receive_lib,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "verify",
-            args: (&receive_lib, &origin1, &receiver, &payload_hash1).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+    context.mock_auth(&receive_lib, "verify", (&receive_lib, &origin1, &receiver, &payload_hash1));
     endpoint_client.verify(&receive_lib, &origin1, &receiver, &payload_hash1);
 
     // Verify nonce 2
     let payload_hash2 = BytesN::from_array(env, &[2u8; 32]);
     let origin2 = Origin { src_eid, sender: sender.clone(), nonce: 2 };
-    env.mock_auths(&[MockAuth {
-        address: &receive_lib,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "verify",
-            args: (&receive_lib, &origin2, &receiver, &payload_hash2).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+    context.mock_auth(&receive_lib, "verify", (&receive_lib, &origin2, &receiver, &payload_hash2));
     endpoint_client.verify(&receive_lib, &origin2, &receiver, &payload_hash2);
 
     // Verify both payload hashes were stored
@@ -170,3 +152,154 @@ fn test_verify_multiple_nonces() {
     assert_eq!(stored_hash1, Some(payload_hash1));
     assert_eq!(stored_hash2, Some(payload_hash2));
 }
+
+// Authorization
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_verify_unauthorized() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let receiver = env.register(MockReceiver, ());
+    let nonce = 1u64;
+
+    // Setup receive library
+    let receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    // Create payload hash
+    let payload_hash = default_payload_hash(env);
+
+    let origin = Origin { src_eid, sender, nonce };
+
+    // Don't mock auth for receive_lib - should panic with Auth error
+    endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash);
+}
+
+// Receive Library Validation
+#[test]
+fn test_verify_invalid_receive_library() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let receiver = env.register(MockReceiver, ());
+    let nonce = 1u64;
+
+    // Setup valid receive library and set as default (so get_receive_library succeeds)
+    let _valid_receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    // Create invalid receive library (different from configured one, not registered, no timeout)
+    // is_valid_receive_library will call get_receive_library (succeeds with default),
+    // then check actual_lib != expected_lib (true), then check timeout (None), so returns false
+    let invalid_receive_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
+    // Don't register or set as default - this makes it invalid
+
+    // Create payload hash
+    let payload_hash = default_payload_hash(env);
+
+    let origin = Origin { src_eid, sender, nonce };
+
+    // Mock auth for invalid receive library
+    context.mock_auth(&invalid_receive_lib, "verify", (&invalid_receive_lib, &origin, &receiver, &payload_hash));
+
+    let result = endpoint_client.try_verify(&invalid_receive_lib, &origin, &receiver, &payload_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InvalidReceiveLibrary.into());
+}
+
+// Payload Hash Validation
+#[test]
+fn test_verify_invalid_payload_hash_empty() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let receiver = env.register(MockReceiver, ());
+    let nonce = 1u64;
+
+    // Setup receive library
+    let receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    // Empty payload hash is not allowed
+    let empty_hash = BytesN::from_array(env, &[0u8; 32]);
+    let origin = Origin { src_eid, sender, nonce };
+
+    // Mock auth for receive_lib
+    context.mock_auth(&receive_lib, "verify", (&receive_lib, &origin, &receiver, &empty_hash));
+
+    let result = endpoint_client.try_verify(&receive_lib, &origin, &receiver, &empty_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InvalidPayloadHash.into());
+}
+
+// Path Validation
+#[test]
+fn test_verify_path_not_initializable() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    // Use MockReceiverReject which rejects initialization (returns false from allow_initialize_path)
+    let receiver = env.register(MockReceiverReject, ());
+    let nonce = 1u64;
+
+    // Setup receive library and set as default (so library validation passes)
+    let receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    // Create payload hash
+    let payload_hash = default_payload_hash(env);
+
+    let origin = Origin { src_eid, sender, nonce };
+
+    // Mock auth for receive_lib
+    context.mock_auth(&receive_lib, "verify", (&receive_lib, &origin, &receiver, &payload_hash));
+
+    // Library validation passes (receive_lib matches default)
+    // initializable checks: lazy_inbound_nonce == 0, and receiver.allow_initialize_path(origin) == false
+    // So initializable returns false, should panic with PathNotInitializable error
+    let result = endpoint_client.try_verify(&receive_lib, &origin, &receiver, &payload_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::PathNotInitializable.into());
+}
+
+#[test]
+fn test_verify_path_not_verifiable() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let receiver = env.register(MockReceiver, ());
+
+    // Setup receive library and set as default (so library validation passes)
+    let receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    // Skip nonce 1 to set lazy_inbound_nonce to 1 (so initializable passes: lazy_nonce > 0)
+    context.mock_auth(&receiver, "skip", (&receiver, &receiver, &src_eid, &sender, &1u64));
+    endpoint_client.skip(&receiver, &receiver, &src_eid, &sender, &1);
+
+    // Create payload hash
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let payload = build_payload(env, &guid, &message);
+    let payload_hash = keccak256(env, &payload);
+
+    // Try to verify nonce 1, but lazy_nonce is already 1, so nonce 1 is not verifiable
+    // verifiable checks: nonce > lazy_inbound_nonce (1 > 1 is false) OR has payload hash (false)
+    let origin = Origin { src_eid, sender, nonce: 1 };
+
+    // Mock auth for receive_lib
+    context.mock_auth(&receive_lib, "verify", (&receive_lib, &origin, &receiver, &payload_hash));
+
+    // Library validation passes, initializable passes (lazy_nonce > 0)
+    // verifiable fails (nonce <= lazy_nonce and no payload hash), should panic with PathNotVerifiable error
+    let result = endpoint_client.try_verify(&receive_lib, &origin, &receiver, &payload_hash);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::PathNotVerifiable.into());
+}

package/contracts/endpoint-v2/src/tests/endpoint_v2/zro.rs

@@ -1,5 +1,4 @@
 use crate::tests::endpoint_setup::setup;
-
 #[test]
 fn test_zro_when_not_set() {
     let context = setup();

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

@@ -0,0 +1,24 @@
+use crate::tests::endpoint_setup::setup;
+// The default_receive_library is per-EID (None for unset EIDs, distinct libs per EID)
+#[test]
+fn test_default_receive_library_none_and_distinct_per_eid() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    let eid_a = context.eid;
+    let eid_b = eid_a + 1;
+    let eid_none = eid_a + 2;
+
+    // Set defaults for two EIDs.
+    let receive_lib_a = context.setup_default_receive_lib(eid_a, 0);
+    let receive_lib_b = context.setup_default_receive_lib(eid_b, 0);
+
+    assert_eq!(endpoint_client.default_receive_library(&eid_a), Some(receive_lib_a.clone()));
+    assert_eq!(endpoint_client.default_receive_library(&eid_b), Some(receive_lib_b.clone()));
+
+    // Different EIDs should be allowed to point to different libs.
+    assert_ne!(receive_lib_a, receive_lib_b);
+
+    // Setting other EIDs should not affect an unset EID.
+    assert_eq!(endpoint_client.default_receive_library(&eid_none), None);
+}

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

@@ -0,0 +1,40 @@
+use soroban_sdk::{testutils::Ledger, vec};
+
+use crate::{tests::endpoint_setup::setup, MessageLibType, Timeout};
+
+// The default_receive_library_timeout is per-EID (None for unset EIDs, distinct values per EID)
+#[test]
+fn test_default_receive_library_timeout_none_and_distinct_per_eid() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let eid_a = context.eid;
+    let eid_b = eid_a + 1;
+    let eid_none = eid_a + 2;
+
+    let now = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = now);
+
+    // Create and register receive libs for each EID.
+    let lib_a = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, eid_a]);
+    let lib_b = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, eid_b]);
+    context.register_library_with_auth(&lib_a);
+    context.register_library_with_auth(&lib_b);
+
+    let timeout_a = Some(Timeout { lib: lib_a.clone(), expiry: now + 1000 });
+    let timeout_b = Some(Timeout { lib: lib_b.clone(), expiry: now + 2000 });
+
+    // Set timeouts as owner.
+    context.mock_owner_auth("set_default_receive_lib_timeout", (&eid_a, &timeout_a));
+    endpoint_client.set_default_receive_lib_timeout(&eid_a, &timeout_a);
+
+    context.mock_owner_auth("set_default_receive_lib_timeout", (&eid_b, &timeout_b));
+    endpoint_client.set_default_receive_lib_timeout(&eid_b, &timeout_b);
+
+    assert_eq!(endpoint_client.default_receive_library_timeout(&eid_a), timeout_a);
+    assert_eq!(endpoint_client.default_receive_library_timeout(&eid_b), timeout_b);
+
+    // Setting other EIDs should not affect an unset EID.
+    assert_eq!(endpoint_client.default_receive_library_timeout(&eid_none), None);
+}

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

@@ -0,0 +1,24 @@
+use crate::tests::endpoint_setup::setup;
+// The default_send_library is per-EID (None for unset EIDs, distinct libs per EID)
+#[test]
+fn test_default_send_library_none_and_distinct_per_eid() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    let eid_a = context.eid;
+    let eid_b = eid_a + 1;
+    let eid_none = eid_a + 2;
+
+    // Set defaults for two EIDs.
+    let (send_lib_a, _fee_recipient_a) = context.setup_default_send_lib(eid_a, 100, 0);
+    let (send_lib_b, _fee_recipient_b) = context.setup_default_send_lib(eid_b, 100, 0);
+
+    assert_eq!(endpoint_client.default_send_library(&eid_a), Some(send_lib_a.clone()));
+    assert_eq!(endpoint_client.default_send_library(&eid_b), Some(send_lib_b.clone()));
+
+    // Different EIDs should be allowed to point to different libs.
+    assert_ne!(send_lib_a, send_lib_b);
+
+    // Setting other EIDs should not affect an unset EID.
+    assert_eq!(endpoint_client.default_send_library(&eid_none), None);
+}

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

@@ -0,0 +1,108 @@
+use soroban_sdk::{testutils::Address as _, vec, Address, Bytes, Vec};
+
+use crate::{
+    errors::EndpointError, tests::endpoint_setup::setup, tests::mock::MockMessageLibClient, MessageLibType,
+    SetConfigParam,
+};
+
+// The get_config requires library to be registered (internal require_registered)
+#[test]
+fn test_get_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 result = endpoint_client.try_get_config(&oapp, &unregistered_lib, &context.eid, &0u32);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlyRegisteredLib.into());
+}
+
+// The get_config returns empty bytes for unset keys
+#[test]
+fn test_get_config_returns_empty_for_unset_key() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let eid = context.eid;
+    let config_type = 7u32;
+
+    let message_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, eid]);
+    context.register_library_with_auth(&message_lib);
+
+    let stored = endpoint_client.get_config(&oapp, &message_lib, &eid, &config_type);
+    assert_eq!(stored, Bytes::new(env));
+}
+
+// The get_config forwards (eid, oapp, config_type) correctly into the message lib
+#[test]
+fn test_get_config_returns_persisted_and_isolated_by_oapp_and_config_type() {
+    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 eid = context.eid;
+    let config_type_a = 1u32;
+    let config_type_b = 2u32;
+
+    let message_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, eid]);
+    context.register_library_with_auth(&message_lib);
+
+    // Seed config directly into the mock library to keep this test focused on get_config passthrough.
+    let lib_client = MockMessageLibClient::new(env, &message_lib);
+    let cfg_a = Bytes::from_slice(env, &[0x01, 0x02, 0x03]);
+    let params_a: Vec<SetConfigParam> =
+        vec![env, SetConfigParam { eid, config_type: config_type_a, config: cfg_a.clone() }];
+    lib_client.set_config(&oapp_a, &params_a);
+
+    // Happy path: exact key returns the stored bytes.
+    assert_eq!(endpoint_client.get_config(&oapp_a, &message_lib, &eid, &config_type_a), cfg_a);
+
+    // Different config_type returns empty.
+    assert_eq!(endpoint_client.get_config(&oapp_a, &message_lib, &eid, &config_type_b), Bytes::new(env));
+
+    // Different OApp returns empty.
+    assert_eq!(endpoint_client.get_config(&oapp_b, &message_lib, &eid, &config_type_a), Bytes::new(env));
+}
+
+// The get_config is isolated by EID and by library address
+#[test]
+fn test_get_config_isolated_by_eid_and_lib() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let eid_a = context.eid;
+    let eid_b = eid_a + 1;
+    let config_type = 1u32;
+
+    let lib_a = context.setup_mock_message_lib(MessageLibType::Send, vec![env, eid_a, eid_b]);
+    let lib_b = context.setup_mock_message_lib(MessageLibType::Send, vec![env, eid_a, eid_b]);
+    context.register_library_with_auth(&lib_a);
+    context.register_library_with_auth(&lib_b);
+
+    // Seed different values into different libs under the same key.
+    let cfg_a = Bytes::from_slice(env, &[0xA1]);
+    let cfg_b = Bytes::from_slice(env, &[0xB2]);
+
+    let lib_a_client = MockMessageLibClient::new(env, &lib_a);
+    let lib_b_client = MockMessageLibClient::new(env, &lib_b);
+
+    let params_a: Vec<SetConfigParam> = vec![env, SetConfigParam { eid: eid_a, config_type, config: cfg_a.clone() }];
+    let params_b: Vec<SetConfigParam> = vec![env, SetConfigParam { eid: eid_a, config_type, config: cfg_b.clone() }];
+    lib_a_client.set_config(&oapp, &params_a);
+    lib_b_client.set_config(&oapp, &params_b);
+
+    assert_eq!(endpoint_client.get_config(&oapp, &lib_a, &eid_a, &config_type), cfg_a);
+    assert_eq!(endpoint_client.get_config(&oapp, &lib_b, &eid_a, &config_type), cfg_b);
+
+    // Different EID (unset) returns empty.
+    assert_eq!(endpoint_client.get_config(&oapp, &lib_a, &eid_b, &config_type), Bytes::new(env));
+}

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

@@ -0,0 +1,52 @@
+use soroban_sdk::{testutils::Address as _, Address};
+
+use crate::tests::{endpoint_setup::setup, mock::MockValidMessageLib};
+
+// The get_library_index is None for arbitrary (unregistered) addresses
+#[test]
+fn test_get_library_index_for_unregistered_library_is_none() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let unregistered = Address::generate(env);
+    assert!(!endpoint_client.is_registered_library(&unregistered));
+    assert_eq!(endpoint_client.get_library_index(&unregistered), None);
+}
+
+// The get_library_index returns Some(index) after successful registration
+#[test]
+fn test_get_library_index_for_registered_library_is_some() {
+    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!(endpoint_client.is_registered_library(&lib));
+    assert_eq!(endpoint_client.get_library_index(&lib), Some(0));
+    assert_eq!(endpoint_client.registered_libraries_count(), 1);
+}
+
+// Indices are sequential and stable across multiple registrations
+#[test]
+fn test_get_library_index_multiple_libraries_are_sequential() {
+    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, ());
+
+    context.register_library_with_auth(&lib0);
+    context.register_library_with_auth(&lib1);
+    context.register_library_with_auth(&lib2);
+
+    assert_eq!(endpoint_client.get_library_index(&lib0), Some(0));
+    assert_eq!(endpoint_client.get_library_index(&lib1), Some(1));
+    assert_eq!(endpoint_client.get_library_index(&lib2), Some(2));
+    assert_eq!(endpoint_client.registered_libraries_count(), 3);
+}