@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,202 @@
+use crate::tests::endpoint_setup::setup;
+use soroban_sdk::{testutils::Address as _, Address};
+use utils::{
+    errors::TtlError,
+    ttl::{TtlConfig, TtlConfigData},
+};
+
+fn ttl_defaults(env: &soroban_sdk::Env, contract: &Address) -> (TtlConfig, TtlConfig) {
+    env.as_contract(contract, || {
+        (
+            TtlConfigData::instance(env).expect("instance config should exist"),
+            TtlConfigData::persistent(env).expect("persistent config should exist"),
+        )
+    })
+}
+
+#[test]
+fn test_set_ttl_config_success() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint = &context.endpoint_client;
+
+    let max_ttl = env.as_contract(&context.endpoint_client.address, || env.storage().max_ttl());
+
+    let instance_threshold = max_ttl / 4;
+    let instance_extend_to = instance_threshold + 1;
+    let persistent_threshold = max_ttl / 5;
+    let persistent_extend_to = persistent_threshold + 2;
+
+    let instance_config = Some(TtlConfig::new(instance_threshold, instance_extend_to));
+    let persistent_config = Some(TtlConfig::new(persistent_threshold, persistent_extend_to));
+
+    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
+    endpoint.set_ttl_config(&instance_config, &persistent_config, &None);
+
+    let (stored_instance, stored_persistent) = ttl_defaults(env, &context.endpoint_client.address);
+
+    assert_eq!(stored_instance, TtlConfig::new(instance_threshold, instance_extend_to));
+    assert_eq!(stored_persistent, TtlConfig::new(persistent_threshold, persistent_extend_to));
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_ttl_config_requires_owner() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint = &context.endpoint_client;
+    let attacker = Address::generate(env);
+
+    let instance_config = Some(TtlConfig::new(1, 2));
+    let persistent_config = Some(TtlConfig::new(1, 2));
+
+    context.mock_auth(&attacker, "set_ttl_config", (&instance_config, &persistent_config));
+
+    endpoint.set_ttl_config(&instance_config, &persistent_config, &None);
+}
+
+#[test]
+fn test_panic_set_ttl_config_invalid_instance_range() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint = &context.endpoint_client;
+
+    let max_ttl = env.as_contract(&context.endpoint_client.address, || env.storage().max_ttl());
+    let instance_threshold = max_ttl / 4 + 2;
+    let instance_extend_to = instance_threshold - 1; // Invalid: extend_to < threshold
+
+    let instance_config = Some(TtlConfig::new(instance_threshold, instance_extend_to));
+    let persistent_config = Some(TtlConfig::new(1, 2));
+
+    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
+
+    assert_eq!(
+        endpoint.try_set_ttl_config(&instance_config, &persistent_config, &None).unwrap_err().unwrap(),
+        TtlError::InvalidTtlConfig.into()
+    );
+}
+
+#[test]
+fn test_panic_set_ttl_config_exceeds_max_ttl() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint = &context.endpoint_client;
+
+    let max_ttl = env.as_contract(&context.endpoint_client.address, || env.storage().max_ttl());
+    let instance_extend_to = max_ttl.checked_add(1).expect("max_ttl is at u32::MAX");
+
+    let instance_config = Some(TtlConfig::new(1, instance_extend_to)); // Invalid: extend_to > max_ttl
+    let persistent_config = Some(TtlConfig::new(1, 2));
+
+    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
+
+    assert_eq!(
+        endpoint.try_set_ttl_config(&instance_config, &persistent_config, &None).unwrap_err().unwrap(),
+        TtlError::InvalidTtlConfig.into()
+    );
+}
+
+// ============================================================================
+// Frozen TTL Config Tests
+// ============================================================================
+
+#[test]
+fn test_is_ttl_config_frozen_default_false() {
+    let context = setup();
+    let endpoint = &context.endpoint_client;
+
+    assert!(!endpoint.is_ttl_config_frozen());
+}
+
+#[test]
+fn test_freeze_ttl_config_success() {
+    let context = setup();
+    let endpoint = &context.endpoint_client;
+
+    assert!(!endpoint.is_ttl_config_frozen());
+
+    context.mock_owner_auth("freeze_ttl_config", ());
+    endpoint.freeze_ttl_config();
+
+    assert!(endpoint.is_ttl_config_frozen());
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_freeze_ttl_config_requires_owner() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint = &context.endpoint_client;
+    let attacker = Address::generate(env);
+
+    context.mock_auth(&attacker, "freeze_ttl_config", ());
+    endpoint.freeze_ttl_config();
+}
+
+#[test]
+fn test_freeze_ttl_config_already_frozen() {
+    let context = setup();
+    let endpoint = &context.endpoint_client;
+
+    // First freeze
+    context.mock_owner_auth("freeze_ttl_config", ());
+    endpoint.freeze_ttl_config();
+
+    // Try to freeze again
+    context.mock_owner_auth("freeze_ttl_config", ());
+    assert_eq!(endpoint.try_freeze_ttl_config().unwrap_err().unwrap(), TtlError::TtlConfigAlreadyFrozen.into());
+}
+
+#[test]
+fn test_set_ttl_config_fails_when_frozen() {
+    let context = setup();
+    let endpoint = &context.endpoint_client;
+
+    // Freeze first
+    context.mock_owner_auth("freeze_ttl_config", ());
+    endpoint.freeze_ttl_config();
+
+    // Try to set TTL config after freeze
+    let instance_config = Some(TtlConfig::new(1, 2));
+    let persistent_config = Some(TtlConfig::new(1, 2));
+
+    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
+    assert_eq!(
+        endpoint.try_set_ttl_config(&instance_config, &persistent_config, &None).unwrap_err().unwrap(),
+        TtlError::TtlConfigFrozen.into()
+    );
+}
+
+#[test]
+fn test_set_ttl_config_then_freeze() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint = &context.endpoint_client;
+
+    // Set custom TTL config
+    let instance_config = Some(TtlConfig::new(100, 200));
+    let persistent_config = Some(TtlConfig::new(300, 400));
+
+    context.mock_owner_auth("set_ttl_config", (&instance_config, &persistent_config, &None::<TtlConfig>));
+    endpoint.set_ttl_config(&instance_config, &persistent_config, &None);
+
+    // Freeze
+    context.mock_owner_auth("freeze_ttl_config", ());
+    endpoint.freeze_ttl_config();
+
+    // Verify config is preserved after freeze
+    let (stored_instance, stored_persistent) = ttl_defaults(env, &context.endpoint_client.address);
+    assert_eq!(stored_instance, TtlConfig::new(100, 200));
+    assert_eq!(stored_persistent, TtlConfig::new(300, 400));
+
+    // Verify frozen
+    assert!(endpoint.is_ttl_config_frozen());
+
+    // Verify cannot modify after freeze
+    let new_instance_config = Some(TtlConfig::new(500, 600));
+    context.mock_owner_auth("set_ttl_config", (&new_instance_config, &persistent_config, &None::<TtlConfig>));
+    assert_eq!(
+        endpoint.try_set_ttl_config(&new_instance_config, &persistent_config, &None).unwrap_err().unwrap(),
+        TtlError::TtlConfigFrozen.into()
+    );
+}

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

@@ -0,0 +1,59 @@
+use crate::{tests::endpoint_setup::setup, Origin};
+use soroban_sdk::{testutils::Address as _, BytesN};
+
+#[test]
+fn test_verifiable_with_new_path() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+    let receiver = soroban_sdk::Address::generate(&context.env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(&context.env, &[1u8; 32]);
+    let origin = Origin { src_eid, sender, nonce: 1 };
+
+    // For a new path (lazy nonce is 0), nonce 1 > 0 should be verifiable
+    let result = endpoint_client.verifiable(&origin, &receiver);
+    assert!(result);
+}
+
+#[test]
+fn test_verifiable_with_higher_nonce() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+    let receiver = soroban_sdk::Address::generate(&context.env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(&context.env, &[1u8; 32]);
+    let origin = Origin { src_eid, sender, nonce: 10 };
+
+    // For a new path (lazy nonce is 0), nonce 10 > 0 should be verifiable
+    let result = endpoint_client.verifiable(&origin, &receiver);
+    assert!(result);
+}
+
+#[test]
+fn test_verifiable_after_skip() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let receiver = soroban_sdk::Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Skip nonce 1
+    use soroban_sdk::{testutils::MockAuth, testutils::MockAuthInvoke, IntoVal};
+    env.mock_auths(&[MockAuth {
+        address: &receiver,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "skip",
+            args: (&receiver, &receiver, &src_eid, &sender, &1u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.skip(&receiver, &receiver, &src_eid, &sender, &1);
+
+    // Now lazy_nonce = 1, nonce 2 > 1 should be verifiable
+    let origin = Origin { src_eid, sender, nonce: 2 };
+    let result = endpoint_client.verifiable(&origin, &receiver);
+    assert!(result);
+}
+

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

@@ -0,0 +1,172 @@
+use crate::util::build_payload;
+use crate::{
+    events::PacketVerified,
+    storage,
+    tests::{endpoint_setup::setup, mock::MockReceiver},
+    util::keccak256,
+    Origin,
+};
+use soroban_sdk::{
+    testutils::{MockAuth, MockAuthInvoke},
+    vec, Bytes, BytesN, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_verify_success() {
+    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_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);
+
+    // 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 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)
+    });
+    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: &[],
+        },
+    }]);
+
+    endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash);
+
+    // Verify PacketVerified event was published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketVerified { origin: origin.clone(), receiver: receiver.clone(), payload_hash: payload_hash.clone() },
+    );
+
+    // 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");
+}
+
+#[test]
+fn test_verify_stores_payload_hash() {
+    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_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);
+
+    // 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 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: &[],
+        },
+    }]);
+
+    endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash);
+
+    // Verify inbound payload hash was stored
+    let stored_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
+    assert_eq!(stored_hash, Some(payload_hash));
+}
+
+#[test]
+fn test_verify_multiple_nonces() {
+    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
+    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);
+
+    // 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: &[],
+        },
+    }]);
+    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: &[],
+        },
+    }]);
+    endpoint_client.verify(&receive_lib, &origin2, &receiver, &payload_hash2);
+
+    // Verify both payload hashes were stored
+    let stored_hash1 = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &1);
+    let stored_hash2 = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &2);
+    assert_eq!(stored_hash1, Some(payload_hash1));
+    assert_eq!(stored_hash2, Some(payload_hash2));
+}

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

@@ -0,0 +1,23 @@
+use crate::tests::endpoint_setup::setup;
+
+#[test]
+fn test_zro_when_not_set() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    let zro_token = endpoint_client.zro();
+    assert_eq!(zro_token, None);
+}
+
+#[test]
+fn test_zro_after_set() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    // Set ZRO token
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    let zro_token = endpoint_client.zro();
+    assert_eq!(zro_token, Some(context.zro_token_client.address));
+}

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

@@ -0,0 +1,10 @@
+mod register_library;
+mod require_registered;
+mod require_supported_eid;
+mod set_config;
+mod set_default_receive_lib_timeout;
+mod set_default_receive_library;
+mod set_default_send_library;
+mod set_receive_library;
+mod set_receive_library_timeout;
+mod set_send_library;

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

@@ -0,0 +1,131 @@
+use crate::{
+    events::LibraryRegistered,
+    storage,
+    tests::{
+        endpoint_setup::setup,
+        mock::{MockMessageLib, MockValidMessageLib},
+    },
+};
+use soroban_sdk::{testutils::Address as _, vec, Address};
+use utils::testing_utils::assert_event;
+
+use crate::errors::EndpointError;
+
+#[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,));
+
+    endpoint_client.register_library(&lib);
+
+    // Assert event was published
+    assert_event(env, &endpoint_client.address, LibraryRegistered { new_lib: lib.clone() });
+
+    // Assert public interface methods work
+    assert!(endpoint_client.is_registered_library(&lib));
+
+    let libraries = endpoint_client.get_registered_libraries(&0, &1);
+    assert_eq!(libraries, vec![&env, lib.clone()]);
+
+    // Assert storage changes directly
+    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");
+
+        // 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");
+
+        // 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");
+
+        // 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");
+    });
+}
+
+#[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);
+
+    // 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());
+}
+
+#[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);
+
+    // 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);
+    assert!(result.is_err());
+}
+
+#[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);
+
+    let library = endpoint_client.get_registered_libraries(&0, &1);
+    assert_eq!(library, vec![env, lib]);
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_register_library_without_owner_auth() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let lib = Address::generate(env);
+    let non_owner = Address::generate(env);
+
+    // Mock auth for non-owner
+    context.mock_auth(&non_owner, "register_library", (&lib,));
+
+    endpoint_client.register_library(&lib);
+}

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

@@ -0,0 +1,35 @@
+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
+fn test_require_registered_with_unregistered_lib() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let unregistered_lib = Address::generate(env);
+
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_registered(env, &unregistered_lib));
+}
+
+#[test]
+fn test_require_registered_with_registered_lib() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // 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);
+
+    // Should not panic
+    env.as_contract(&endpoint_client.address, || EndpointV2::require_registered(env, &lib));
+}

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

@@ -0,0 +1,28 @@
+use crate::{tests::endpoint_setup::setup, EndpointV2, MessageLibType};
+use soroban_sdk::{testutils::Address as _, vec, Address};
+
+#[test]
+#[should_panic(expected = "Error(Contract, #22)")] // EndpointError::UnsupportedEid
+fn test_require_supported_eid_with_unsupported() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let unsupported_eid = context.eid + 1;
+    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, unsupported_eid));
+}
+
+#[test]
+#[should_panic(expected = "trying to get non-existing value for contract instance")]
+fn test_require_supported_eid_with_non_deployed_lib() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Address that doesn't have a contract deployed
+    let non_existent_lib = Address::generate(env);
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::require_supported_eid(env, &non_existent_lib, context.eid)
+    });
+}