@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

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

@@ -0,0 +1,92 @@
+use soroban_sdk::{testutils::Address as _, vec, Address};
+
+use crate::{errors::EndpointError, tests::endpoint_setup::setup, MessageLibType, ResolvedLibrary};
+
+// The get_receive_library resolves default vs custom and is isolated per receiver
+#[test]
+fn test_get_receive_library_default_custom_and_isolated_per_receiver() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = context.eid;
+    let receiver_a = Address::generate(env);
+    let receiver_b = Address::generate(env);
+
+    let default_receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    // No custom set => both receivers resolve to default.
+    assert_eq!(
+        endpoint_client.get_receive_library(&receiver_a, &src_eid),
+        ResolvedLibrary { lib: default_receive_lib.clone(), is_default: true }
+    );
+    assert_eq!(
+        endpoint_client.get_receive_library(&receiver_b, &src_eid),
+        ResolvedLibrary { lib: default_receive_lib, is_default: true }
+    );
+
+    // Create and register a custom receive lib for the same eid.
+    let custom_receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, src_eid]);
+    context.register_library_with_auth(&custom_receive_lib);
+
+    // Receiver A sets a custom receive library for itself.
+    context.mock_auth(
+        &receiver_a,
+        "set_receive_library",
+        (&receiver_a, &receiver_a, &src_eid, &Some(custom_receive_lib.clone()), &0u64),
+    );
+    endpoint_client.set_receive_library(&receiver_a, &receiver_a, &src_eid, &Some(custom_receive_lib.clone()), &0u64);
+
+    // Receiver A resolves to custom.
+    assert_eq!(
+        endpoint_client.get_receive_library(&receiver_a, &src_eid),
+        ResolvedLibrary { lib: custom_receive_lib, is_default: false }
+    );
+
+    // Receiver B resolves to default.
+    assert_eq!(
+        endpoint_client.get_receive_library(&receiver_b, &src_eid),
+        ResolvedLibrary { lib: endpoint_client.get_receive_library(&receiver_b, &src_eid).lib, is_default: true }
+    );
+}
+
+// The get_receive_library returns custom even when no default exists
+#[test]
+fn test_get_receive_library_custom_without_default() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    let custom_receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, src_eid]);
+    context.register_library_with_auth(&custom_receive_lib);
+
+    context.mock_auth(
+        &receiver,
+        "set_receive_library",
+        (&receiver, &receiver, &src_eid, &Some(custom_receive_lib.clone()), &0u64),
+    );
+    endpoint_client.set_receive_library(&receiver, &receiver, &src_eid, &Some(custom_receive_lib.clone()), &0u64);
+
+    assert_eq!(
+        endpoint_client.get_receive_library(&receiver, &src_eid),
+        ResolvedLibrary { lib: custom_receive_lib, is_default: false }
+    );
+}
+
+// The get_receive_library fails when neither default nor custom exists
+#[test]
+fn test_get_receive_library_fails_without_default_and_custom() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    // Missing both default and custom => DefaultReceiveLibUnavailable.
+    let result = endpoint_client.try_get_receive_library(&receiver, &src_eid);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::DefaultReceiveLibUnavailable.into());
+}

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

@@ -0,0 +1,74 @@
+use soroban_sdk::vec;
+
+use crate::tests::{endpoint_setup::setup, mock::MockValidMessageLib};
+
+// Pagination and bounds behavior
+#[test]
+fn test_get_registered_libraries_pagination_and_bounds() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Empty set.
+    assert_eq!(endpoint_client.registered_libraries_count(), 0);
+    assert_eq!(endpoint_client.get_registered_libraries(&0, &1).len(), 0);
+    assert_eq!(endpoint_client.get_registered_libraries(&999, &1).len(), 0);
+
+    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);
+
+    // max_count == 0 => empty.
+    assert_eq!(endpoint_client.get_registered_libraries(&0, &0).len(), 0);
+    assert_eq!(endpoint_client.get_registered_libraries(&1, &0).len(), 0);
+
+    // start within bounds, normal pages.
+    assert_eq!(endpoint_client.get_registered_libraries(&0, &2), vec![&env, lib0.clone(), lib1.clone()]);
+    assert_eq!(endpoint_client.get_registered_libraries(&1, &2), vec![&env, lib1.clone(), lib2.clone()]);
+    assert_eq!(endpoint_client.get_registered_libraries(&2, &2), vec![&env, lib2.clone()]);
+
+    // start >= count => empty.
+    assert_eq!(endpoint_client.get_registered_libraries(&3, &1).len(), 0);
+    assert_eq!(endpoint_client.get_registered_libraries(&4, &10).len(), 0);
+}
+
+// Ordering follows registration index
+#[test]
+fn test_get_registered_libraries_orders_by_registration_index() {
+    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);
+
+    let libs = endpoint_client.get_registered_libraries(&0, &10);
+    assert_eq!(libs, vec![&env, lib0.clone(), lib1.clone()]);
+}
+
+// The max_count larger than total count returns all remaining libraries
+#[test]
+fn test_get_registered_libraries_max_count_exceeds_total_returns_all() {
+    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);
+
+    // max_count is larger than total count; should return all.
+    let libs = endpoint_client.get_registered_libraries(&0, &100);
+    assert_eq!(libs, vec![&env, lib0.clone(), lib1.clone(), lib2.clone()]);
+}

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

@@ -0,0 +1,83 @@
+use soroban_sdk::{testutils::Address as _, vec, Address};
+
+use crate::{errors::EndpointError, tests::endpoint_setup::setup, MessageLibType, ResolvedLibrary};
+
+// The get_send_library resolves default vs custom and is isolated per sender
+#[test]
+fn test_get_send_library_default_custom_and_isolated_per_sender() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let dst_eid = context.eid;
+    let sender_a = Address::generate(env);
+    let sender_b = Address::generate(env);
+
+    let (default_send_lib, _fee_recipient) = context.setup_default_send_lib(dst_eid, 100, 0);
+
+    // No custom set => both senders resolve to default.
+    assert_eq!(
+        endpoint_client.get_send_library(&sender_a, &dst_eid),
+        ResolvedLibrary { lib: default_send_lib.clone(), is_default: true }
+    );
+    assert_eq!(
+        endpoint_client.get_send_library(&sender_b, &dst_eid),
+        ResolvedLibrary { lib: default_send_lib.clone(), is_default: true }
+    );
+
+    // Create and register a custom send lib for the same eid.
+    let custom_send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, dst_eid]);
+    context.register_library_with_auth(&custom_send_lib);
+
+    // Sender A sets a custom send library.
+    context.mock_auth(&sender_a, "set_send_library", (&sender_a, &sender_a, &dst_eid, &Some(custom_send_lib.clone())));
+    endpoint_client.set_send_library(&sender_a, &sender_a, &dst_eid, &Some(custom_send_lib.clone()));
+
+    // Sender A resolves to custom.
+    let resolved_a = endpoint_client.get_send_library(&sender_a, &dst_eid);
+    assert_eq!(resolved_a, ResolvedLibrary { lib: custom_send_lib, is_default: false });
+
+    // Sender B resolves to default.
+    let resolved_b = endpoint_client.get_send_library(&sender_b, &dst_eid);
+    assert_eq!(resolved_b, ResolvedLibrary { lib: default_send_lib, is_default: true });
+}
+
+// The get_send_library returns custom even when no default exists
+#[test]
+fn test_get_send_library_custom_without_default() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let dst_eid_custom_only = context.eid;
+    let sender = Address::generate(env);
+
+    // Custom without default: register + set custom, then resolve to custom.
+    let custom_send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, dst_eid_custom_only]);
+    context.register_library_with_auth(&custom_send_lib);
+    context.mock_auth(
+        &sender,
+        "set_send_library",
+        (&sender, &sender, &dst_eid_custom_only, &Some(custom_send_lib.clone())),
+    );
+    endpoint_client.set_send_library(&sender, &sender, &dst_eid_custom_only, &Some(custom_send_lib.clone()));
+    assert_eq!(
+        endpoint_client.get_send_library(&sender, &dst_eid_custom_only),
+        ResolvedLibrary { lib: custom_send_lib, is_default: false }
+    );
+}
+
+// The get_send_library fails when neither default nor custom exists
+#[test]
+fn test_get_send_library_fails_without_default_and_custom() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let dst_eid = context.eid;
+    let sender = Address::generate(env);
+
+    // Missing both default and custom => DefaultSendLibUnavailable.
+    let result = endpoint_client.try_get_send_library(&sender, &dst_eid);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::DefaultSendLibUnavailable.into());
+}

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

@@ -0,0 +1,32 @@
+use soroban_sdk::{testutils::Address as _, Address};
+
+use crate::tests::endpoint_setup::setup;
+// The is_registered_library is false for arbitrary addresses
+#[test]
+fn test_is_registered_library_false_for_unregistered_address() {
+    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));
+}
+
+// The is_registered_library becomes true after successful registration
+#[test]
+fn test_is_registered_library_true_after_register() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let lib = context.setup_mock_message_lib(crate::MessageLibType::Send, soroban_sdk::vec![env, context.eid]);
+
+    // Before registering.
+    assert!(!endpoint_client.is_registered_library(&lib));
+
+    // Register as owner.
+    context.register_library_with_auth(&lib);
+
+    // After registering.
+    assert!(endpoint_client.is_registered_library(&lib));
+}

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

@@ -0,0 +1,28 @@
+use crate::tests::endpoint_setup::setup;
+// The is_supported_eid view reflects whether BOTH default send & receive libraries exist, and is isolated per-EID
+
+#[test]
+fn test_is_supported_eid_requires_both_defaults_per_eid() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    let eid = context.eid;
+    let receive_only_eid = eid + 2;
+
+    // No defaults set for any EID.
+    assert!(!endpoint_client.is_supported_eid(&eid));
+    assert!(!endpoint_client.is_supported_eid(&receive_only_eid));
+
+    // Only default send set => still not supported.
+    let _ = context.setup_default_send_lib(eid, 100, 0);
+    assert!(!endpoint_client.is_supported_eid(&eid));
+
+    // Only default receive set (on a different EID) => still not supported.
+    let _ = context.setup_default_receive_lib(receive_only_eid, 0);
+    assert!(!endpoint_client.is_supported_eid(&receive_only_eid));
+
+    // Both defaults set => supported.
+    let _ = context.setup_default_receive_lib(eid, 0);
+    assert!(endpoint_client.is_supported_eid(&eid));
+    assert!(!endpoint_client.is_supported_eid(&receive_only_eid));
+}

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

@@ -0,0 +1,261 @@
+use soroban_sdk::{
+    testutils::{Address as _, Ledger},
+    vec, Address,
+};
+
+use crate::{tests::endpoint_setup::setup, Timeout};
+
+// Default receive library rotation (default timeout / grace period)
+#[test]
+fn test_is_valid_receive_library_allows_old_default_receive_library_within_grace_period() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let current_timestamp = 1_700_000_000u64;
+    let grace_period = 1_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    // Set an initial default receive library, then rotate it with a grace period.
+    let old_default = context.setup_default_receive_lib(src_eid, 0);
+    let new_default = context.setup_default_receive_lib(src_eid, grace_period);
+
+    // Old default is still valid due to the default timeout (grace period).
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &old_default));
+    // Current default is always valid.
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &new_default));
+}
+
+#[test]
+fn test_is_valid_receive_library_rejects_old_default_receive_library_after_grace_period_expires() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let current_timestamp = 1_700_000_000u64;
+    let grace_period = 1_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    let old_default = context.setup_default_receive_lib(src_eid, 0);
+    let new_default = context.setup_default_receive_lib(src_eid, grace_period);
+
+    // Expire the timeout: expiry <= timestamp means expired.
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp + grace_period);
+
+    assert!(!endpoint_client.is_valid_receive_library(&receiver, &src_eid, &old_default));
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &new_default));
+}
+
+#[test]
+fn test_is_valid_receive_library_allows_timeout_library_set_by_owner() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let now = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = now);
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    // Configure a default receive library.
+    let default_receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    // Owner sets a default receive library timeout for a different (registered) library.
+    let timeout_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
+    context.register_library_with_auth(&timeout_lib);
+    let timeout = Some(Timeout { lib: timeout_lib.clone(), expiry: now + 1000 });
+    context.mock_owner_auth("set_default_receive_lib_timeout", (&src_eid, &timeout));
+    endpoint_client.set_default_receive_lib_timeout(&src_eid, &timeout);
+
+    // The current default is always valid, and the timeout lib becomes valid until expiry.
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &default_receive_lib));
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &timeout_lib));
+
+    // Other registered libs are still invalid.
+    let other_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
+    context.register_library_with_auth(&other_lib);
+    assert!(!endpoint_client.is_valid_receive_library(&receiver, &src_eid, &other_lib));
+}
+
+// Custom receive library rotation (per-receiver timeout / grace period)
+#[test]
+fn test_is_valid_receive_library_allows_old_custom_receive_library_within_grace_period() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let current_timestamp = 1_700_000_000u64;
+    let grace_period = 1_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    // Set old custom lib (no grace), then rotate to a new custom lib with grace.
+    let old_custom = context.setup_receive_library(&receiver, &receiver, src_eid, 0);
+    let new_custom = context.setup_receive_library(&receiver, &receiver, src_eid, grace_period);
+
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &old_custom));
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &new_custom));
+}
+
+#[test]
+fn test_is_valid_receive_library_rejects_old_custom_receive_library_after_grace_period_expires() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let current_timestamp = 1_700_000_000u64;
+    let grace_period = 1_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    let old_custom = context.setup_receive_library(&receiver, &receiver, src_eid, 0);
+    let new_custom = context.setup_receive_library(&receiver, &receiver, src_eid, grace_period);
+
+    // Expire the timeout.
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp + grace_period);
+
+    assert!(!endpoint_client.is_valid_receive_library(&receiver, &src_eid, &old_custom));
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &new_custom));
+}
+
+// Unrelated libraries are rejected unless covered by a matching timeout
+#[test]
+fn test_is_valid_receive_library_rejects_unrelated_library_without_timeout() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    // Configure a default receive library.
+    let default_receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    // A registered, but unrelated, library should not be valid if no timeout applies.
+    let unrelated_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
+    context.register_library_with_auth(&unrelated_lib);
+
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &default_receive_lib));
+    assert!(!endpoint_client.is_valid_receive_library(&receiver, &src_eid, &unrelated_lib));
+}
+
+#[test]
+fn test_is_valid_receive_library_rejects_unrelated_library_even_when_default_timeout_exists() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let current_timestamp = 1_700_000_000u64;
+    let grace_period = 1_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    // Rotate default receive library with grace so a default timeout exists.
+    let old_default = context.setup_default_receive_lib(src_eid, 0);
+    let new_default = context.setup_default_receive_lib(src_eid, grace_period);
+
+    // A registered, unrelated library must not be valid unless it matches the timeout's lib.
+    let unrelated_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
+    context.register_library_with_auth(&unrelated_lib);
+
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &old_default));
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &new_default));
+    assert!(!endpoint_client.is_valid_receive_library(&receiver, &src_eid, &unrelated_lib));
+}
+
+#[test]
+fn test_is_valid_receive_library_rejects_unrelated_library_even_when_custom_timeout_exists() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let current_timestamp = 1_700_000_000u64;
+    let grace_period = 1_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    // Rotate a custom receive library with grace so a per-receiver timeout exists.
+    let old_custom = context.setup_receive_library(&receiver, &receiver, src_eid, 0);
+    let new_custom = context.setup_receive_library(&receiver, &receiver, src_eid, grace_period);
+
+    let unrelated_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
+    context.register_library_with_auth(&unrelated_lib);
+
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &old_custom));
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &new_custom));
+    assert!(!endpoint_client.is_valid_receive_library(&receiver, &src_eid, &unrelated_lib));
+}
+
+// Custom configuration ignores the default receive library timeout
+#[test]
+fn test_is_valid_receive_library_custom_configuration_ignores_default_timeout() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let current_timestamp = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let grace_period = 1_000u64;
+    let src_eid = context.eid;
+    let receiver = Address::generate(env);
+
+    // Rotate default receive library with grace, which would normally allow old_default.
+    let old_default = context.setup_default_receive_lib(src_eid, 0);
+    let _ = context.setup_default_receive_lib(src_eid, grace_period);
+
+    // Sanity: old default is valid for a receiver when the receiver uses default.
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &old_default));
+
+    // Receiver switches to a custom receive library. From now on, default timeout must NOT apply.
+    let custom_receive_lib = context.setup_receive_library(&receiver, &receiver, src_eid, 0);
+
+    // After custom is configured, old_default is no longer valid (no per-receiver timeout was set for it).
+    assert!(!endpoint_client.is_valid_receive_library(&receiver, &src_eid, &old_default));
+    assert!(endpoint_client.is_valid_receive_library(&receiver, &src_eid, &custom_receive_lib));
+}
+
+// Custom library timeout is isolated per receiver
+#[test]
+fn test_is_valid_receive_library_custom_timeout_isolated_per_receiver() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let current_timestamp = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let grace_period = 1_000u64;
+    let src_eid = context.eid;
+    let receiver_a = Address::generate(env);
+    let receiver_b = Address::generate(env);
+
+    // Ensure receiver_b has a valid default receive library so the view does not panic.
+    context.setup_default_receive_lib(src_eid, 0);
+
+    // Receiver A rotates custom lib with grace.
+    let old_custom = context.setup_receive_library(&receiver_a, &receiver_a, src_eid, 0);
+    let new_custom = context.setup_receive_library(&receiver_a, &receiver_a, src_eid, grace_period);
+
+    // Receiver A: old is valid within grace.
+    assert!(endpoint_client.is_valid_receive_library(&receiver_a, &src_eid, &old_custom));
+    assert!(endpoint_client.is_valid_receive_library(&receiver_a, &src_eid, &new_custom));
+
+    // Receiver B: no receive library config => old_custom is not valid.
+    assert!(!endpoint_client.is_valid_receive_library(&receiver_b, &src_eid, &old_custom));
+}

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

@@ -1,5 +1,20 @@
+mod default_receive_library;
+mod default_receive_library_timeout;
+mod default_send_library;
+mod get_config;
+mod get_library_index;
+mod get_receive_library;
+mod get_registered_libraries;
+mod get_send_library;
+mod is_registered_library;
+mod is_supported_eid;
+mod is_valid_receive_library;
+mod receive_library_timeout;
 mod register_library;
+mod registered_libraries_count;
+mod require_receive_lib_for_eid;
 mod require_registered;
+mod require_send_lib_for_eid;
 mod require_supported_eid;
 mod set_config;
 mod set_default_receive_lib_timeout;
@@ -8,3 +23,4 @@ mod set_default_send_library;
 mod set_receive_library;
 mod set_receive_library_timeout;
 mod set_send_library;
+mod timeout;

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

@@ -0,0 +1,62 @@
+use soroban_sdk::{testutils::Address as _, testutils::Ledger, vec, Address};
+
+use crate::{tests::endpoint_setup::setup, MessageLibType, Timeout};
+
+// The receive_library_timeout is scoped by (receiver, src_eid)
+#[test]
+fn test_receive_library_timeout_none_and_distinct_per_receiver_and_eid() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver_a = Address::generate(env);
+    let receiver_b = Address::generate(env);
+
+    let eid_a = context.eid;
+    let eid_b = eid_a + 1;
+    let eid_none = eid_a + 2;
+
+    // Prepare timestamp.
+    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);
+
+    // Each receiver sets a custom receive library for its EID (required: non-default receive library).
+    context.mock_auth(
+        &receiver_a,
+        "set_receive_library",
+        (&receiver_a, &receiver_a, &eid_a, &Some(lib_a.clone()), &0u64),
+    );
+    endpoint_client.set_receive_library(&receiver_a, &receiver_a, &eid_a, &Some(lib_a.clone()), &0u64);
+
+    context.mock_auth(
+        &receiver_b,
+        "set_receive_library",
+        (&receiver_b, &receiver_b, &eid_b, &Some(lib_b.clone()), &0u64),
+    );
+    endpoint_client.set_receive_library(&receiver_b, &receiver_b, &eid_b, &Some(lib_b.clone()), &0u64);
+
+    // Set timeouts.
+    let timeout_a = Some(Timeout { lib: lib_a.clone(), expiry: now + 1000 });
+    let timeout_b = Some(Timeout { lib: lib_b.clone(), expiry: now + 2000 });
+
+    context.mock_auth(&receiver_a, "set_receive_library_timeout", (&receiver_a, &receiver_a, &eid_a, &timeout_a));
+    endpoint_client.set_receive_library_timeout(&receiver_a, &receiver_a, &eid_a, &timeout_a);
+
+    context.mock_auth(&receiver_b, "set_receive_library_timeout", (&receiver_b, &receiver_b, &eid_b, &timeout_b));
+    endpoint_client.set_receive_library_timeout(&receiver_b, &receiver_b, &eid_b, &timeout_b);
+
+    // Verify view results.
+    assert_eq!(endpoint_client.receive_library_timeout(&receiver_a, &eid_a), timeout_a);
+    assert_eq!(endpoint_client.receive_library_timeout(&receiver_b, &eid_b), timeout_b);
+
+    // Unset combinations remain None.
+    assert_eq!(endpoint_client.receive_library_timeout(&receiver_a, &eid_none), None);
+    assert_eq!(endpoint_client.receive_library_timeout(&receiver_b, &eid_none), None);
+    assert_eq!(endpoint_client.receive_library_timeout(&Address::generate(env), &eid_a), None);
+}