@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,180 @@
+use soroban_sdk::{testutils::Address as _, vec, Address};
+
+use crate::{
+    errors::EndpointError, events::DefaultSendLibrarySet, storage, tests::endpoint_setup::setup, MessageLibType,
+};
+use utils::testing_utils::assert_event;
+
+// Integration tests for set_default_send_library
+#[test]
+fn test_set_default_send_library_unsupported_eid() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let unsupported_eid = context.eid + 1;
+
+    // Create and register a send lib that only supports TEST_context.eid
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    // Mock owner auth for register_library
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+
+    // Mock owner auth for set_default_send_library
+    context.mock_owner_auth("set_default_send_library", (&unsupported_eid, &send_lib));
+
+    // Try to set it as default for unsupported eid
+    let result = endpoint_client.try_set_default_send_library(&unsupported_eid, &send_lib);
+
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::UnsupportedEid.into());
+}
+
+#[test]
+fn test_set_default_send_library_wrong_lib_type() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Create and register a receive-only lib that supports eid 1
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Mock owner auth for register_library
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+
+    // Mock owner auth for set_default_send_library
+    context.mock_owner_auth("set_default_send_library", (&context.eid, &receive_lib));
+
+    // Try to set it as default send library
+    let result = endpoint_client.try_set_default_send_library(&context.eid, &receive_lib);
+
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlySendLib.into());
+}
+
+#[test]
+fn test_set_default_send_library_unregistered_lib() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Create but don't register a valid send lib
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    // Mock owner auth for set_default_send_library
+    context.mock_owner_auth("set_default_send_library", (&context.eid, &send_lib));
+
+    // Try to set it as default without registering
+    let result = endpoint_client.try_set_default_send_library(&context.eid, &send_lib);
+
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlyRegisteredLib.into());
+}
+
+#[test]
+fn test_set_default_send_library_non_deployed_lib() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Address without any contract deployed
+    let non_existent_lib = Address::generate(env);
+
+    // Mock owner auth for set_default_send_library
+    context.mock_owner_auth("set_default_send_library", (&context.eid, &non_existent_lib));
+
+    // Try to set a non-existent contract as default
+    let result = endpoint_client.try_set_default_send_library(&context.eid, &non_existent_lib);
+
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_set_default_send_library_success() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Create and register a valid send lib that supports eid 1
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    // Mock owner auth for register_library
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+
+    // Verify initial state - default send library should not be set
+    assert_eq!(endpoint_client.default_send_library(&context.eid), None);
+    let initial_lib =
+        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::default_send_library(env, context.eid));
+    assert_eq!(initial_lib, None, "Initial default send library should be None");
+
+    // Mock owner auth for set_default_send_library
+    context.mock_owner_auth("set_default_send_library", (&context.eid, &send_lib));
+
+    // Should succeed
+    endpoint_client.set_default_send_library(&context.eid, &send_lib);
+
+    // Verify the event was published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        DefaultSendLibrarySet { dst_eid: context.eid, new_lib: send_lib.clone() },
+    );
+
+    // Verify it was set correctly via public interface
+    assert_eq!(endpoint_client.default_send_library(&context.eid), Some(send_lib.clone()));
+
+    // Assert storage change directly
+    let stored_lib =
+        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::default_send_library(env, context.eid));
+    assert_eq!(stored_lib, Some(send_lib), "Storage should contain the default send library");
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_default_send_library_requires_owner_auth() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let non_owner = Address::generate(env);
+
+    // Create and register a valid send lib
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    // Mock owner auth for register_library
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+
+    // Mock auth for the non-owner (not the owner)
+    context.mock_auth(&non_owner, "set_default_send_library", (&context.eid, &send_lib));
+
+    // Should fail when non-owner tries to set
+    endpoint_client.set_default_send_library(&context.eid, &send_lib);
+}
+
+#[test]
+fn test_set_default_send_library_same_value() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Create and register a valid send lib that supports eid 1
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    // Mock owner auth for register_library
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+
+    // Mock owner auth for set_default_send_library
+    context.mock_owner_auth("set_default_send_library", (&context.eid, &send_lib));
+
+    // Should succeed
+    endpoint_client.set_default_send_library(&context.eid, &send_lib);
+
+    context.mock_owner_auth("set_default_send_library", (&context.eid, &send_lib));
+
+    // Try to set same library again
+    let result = endpoint_client.try_set_default_send_library(&context.eid, &send_lib);
+
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::SameValue.into());
+}

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

@@ -0,0 +1,405 @@
+use soroban_sdk::{
+    testutils::{Address as _, Ledger, MockAuth, MockAuthInvoke},
+    vec, Address, IntoVal,
+};
+
+use crate::{
+    errors::EndpointError,
+    events::{ReceiveLibrarySet, ReceiveLibraryTimeoutSet},
+    storage,
+    tests::endpoint_setup::setup,
+    MessageLibType, Timeout,
+};
+use utils::testing_utils::assert_event;
+
+// Tests for set_receive_library
+#[test]
+fn test_set_receive_library_requires_oapp_auth() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let unauthorized_caller = Address::generate(env);
+
+    // Create and register a valid receive lib
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+
+    // Mock auth for unauthorized caller (not the oapp or its delegate)
+    env.mock_auths(&[MockAuth {
+        address: &unauthorized_caller,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&unauthorized_caller, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    // Should fail with Unauthorized error
+    let result =
+        endpoint_client.try_set_receive_library(&unauthorized_caller, &oapp, &context.eid, &Some(receive_lib), &0u64);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::Unauthorized.into());
+}
+
+#[test]
+fn test_set_receive_library_unregistered_lib() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    // Create but don't register a valid receive lib
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Mock auth for oapp
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    // Should fail with unregistered library error
+    let result = endpoint_client.try_set_receive_library(&oapp, &oapp, &context.eid, &Some(receive_lib), &0u64);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlyRegisteredLib.into());
+}
+
+#[test]
+fn test_set_receive_library_wrong_lib_type() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    // Create and register a send-only lib
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+
+    // Mock auth for oapp
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(send_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    // Should fail with wrong library type error
+    let result = endpoint_client.try_set_receive_library(&oapp, &oapp, &context.eid, &Some(send_lib), &0u64);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlyReceiveLib.into());
+}
+
+#[test]
+fn test_set_receive_library_unsupported_eid() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let unsupported_eid = context.eid + 1;
+
+    // Create and register a receive lib that only supports TEST_context.eid
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+
+    // Mock auth for oapp
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &unsupported_eid, &Some(receive_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    // Should fail with unsupported eid error
+    let result = endpoint_client.try_set_receive_library(&oapp, &oapp, &unsupported_eid, &Some(receive_lib), &0u64);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::UnsupportedEid.into());
+}
+
+#[test]
+fn test_set_receive_library_same_value() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    // Create and register a valid receive lib
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+
+    // First set with oapp auth
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_receive_library(&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64);
+
+    // Try to set the same library again
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let result = endpoint_client.try_set_receive_library(&oapp, &oapp, &context.eid, &Some(receive_lib), &0u64);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::SameValue.into());
+}
+
+#[test]
+fn test_set_receive_library_success_no_grace_period() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    // Create and register a valid receive lib
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+
+    // Verify it was not set
+    assert_eq!(
+        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::receive_library(
+            env,
+            &oapp,
+            context.eid
+        )),
+        None
+    );
+
+    // Set with oapp auth
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    endpoint_client.set_receive_library(&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64);
+
+    assert_event(
+        env,
+        &endpoint_client.address,
+        ReceiveLibraryTimeoutSet { receiver: oapp.clone(), eid: context.eid, timeout: None },
+    );
+
+    // Verify it was set correctly
+    assert_eq!(
+        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::receive_library(
+            env,
+            &oapp,
+            context.eid
+        )),
+        Some(receive_lib)
+    );
+    assert_eq!(endpoint_client.receive_library_timeout(&oapp, &context.eid), None);
+}
+
+#[test]
+fn test_set_receive_library_success_with_grace_period() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let current_timestamp = 1_700_000_000;
+    let grace_period = 1000;
+
+    // Set the ledger timestamp
+    env.ledger().with_mut(|li| {
+        li.timestamp = current_timestamp;
+    });
+
+    // Create and register two valid receive libs
+    let old_receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+    let new_receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Register both libraries with owner auth
+    context.mock_owner_auth("register_library", (&old_receive_lib,));
+    endpoint_client.register_library(&old_receive_lib);
+    context.mock_owner_auth("register_library", (&new_receive_lib,));
+    endpoint_client.register_library(&new_receive_lib);
+
+    // First set the old library without grace period
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(old_receive_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_receive_library(&oapp, &oapp, &context.eid, &Some(old_receive_lib.clone()), &0u64);
+
+    // Now set the new library with grace period
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(new_receive_lib.clone()), &grace_period).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_receive_library(&oapp, &oapp, &context.eid, &Some(new_receive_lib.clone()), &grace_period);
+
+    let expected_timeout = Some(Timeout { lib: old_receive_lib.clone(), expiry: current_timestamp + grace_period });
+
+    // Verify the events were published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        ReceiveLibraryTimeoutSet { receiver: oapp.clone(), eid: context.eid, timeout: expected_timeout.clone() },
+    );
+    assert_event(
+        env,
+        &endpoint_client.address,
+        ReceiveLibrarySet { receiver: oapp.clone(), src_eid: context.eid, new_lib: Some(new_receive_lib.clone()) },
+    );
+
+    // Verify the library was updated
+    assert_eq!(
+        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::receive_library(
+            env,
+            &oapp,
+            context.eid
+        )),
+        Some(new_receive_lib)
+    );
+
+    // Verify the timeout was set correctly
+    assert_eq!(endpoint_client.receive_library_timeout(&oapp, &context.eid), expected_timeout);
+}
+
+#[test]
+fn test_set_receive_library_grace_period_requires_both_libs() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let grace_period = 1000;
+
+    // Create and register a valid receive lib
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+
+    // Try to set library with grace period when there's no existing library
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &grace_period).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let result = endpoint_client.try_set_receive_library(&oapp, &oapp, &context.eid, &Some(receive_lib), &grace_period);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlyNonDefaultLib.into());
+}
+
+#[test]
+fn test_set_receive_library_clear_library() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    // Create and register a valid receive lib
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+
+    // First set a library
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_receive_library(&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64);
+
+    // Now clear the library by setting to None
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &None::<Address>, &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_receive_library(&oapp, &oapp, &context.eid, &None, &0u64);
+
+    // Verify the event was published with None for both receive_library_set and receive_library_timeout_set
+    assert_event(
+        env,
+        &endpoint_client.address,
+        ReceiveLibrarySet { receiver: oapp.clone(), src_eid: context.eid, new_lib: None },
+    );
+    assert_event(
+        env,
+        &endpoint_client.address,
+        ReceiveLibraryTimeoutSet { receiver: oapp.clone(), eid: context.eid, timeout: None },
+    );
+
+    // Verify it was cleared
+    assert_eq!(
+        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::receive_library(
+            env,
+            &oapp,
+            context.eid
+        )),
+        None
+    );
+}

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

@@ -0,0 +1,80 @@
+use soroban_sdk::{
+    testutils::{Address as _, Ledger, MockAuth, MockAuthInvoke},
+    vec, Address, IntoVal,
+};
+
+use crate::{events::ReceiveLibraryTimeoutSet, storage, tests::endpoint_setup::setup, MessageLibType, Timeout};
+use utils::testing_utils::assert_event;
+
+// Tests for set_receive_library_timeout (OApp-level control)
+#[test]
+fn test_set_receive_library_timeout_success() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let current_timestamp = 1_700_000_000;
+    let grace_period = 1000;
+
+    // Set the ledger timestamp
+    env.ledger().with_mut(|li| {
+        li.timestamp = current_timestamp;
+    });
+
+    // Create and register a valid receive lib
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+
+    // Register the library with owner auth
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+
+    // First set a receive library (non-default) to satisfy the requirement
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library",
+            args: (&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_receive_library(&oapp, &oapp, &context.eid, &Some(receive_lib.clone()), &0u64);
+
+    // Create a timeout
+    let timeout = Some(Timeout { lib: receive_lib.clone(), expiry: current_timestamp + grace_period });
+
+    // Verify initial state - timeout should not be set
+    let initial_timeout = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::receive_library_timeout(env, &oapp, context.eid)
+    });
+    assert_eq!(initial_timeout, None, "Initial receive library timeout should be None");
+
+    // Set the timeout with oapp auth
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_receive_library_timeout",
+            args: (&oapp, &oapp, &context.eid, &timeout).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_receive_library_timeout(&oapp, &oapp, &context.eid, &timeout);
+
+    // Verify the event was published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        ReceiveLibraryTimeoutSet { receiver: oapp.clone(), eid: context.eid, timeout: timeout.clone() },
+    );
+
+    // Verify storage was updated via public interface
+    assert_eq!(endpoint_client.receive_library_timeout(&oapp, &context.eid), timeout.clone());
+
+    // Assert storage change directly
+    let stored_timeout = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::receive_library_timeout(env, &oapp, context.eid)
+    });
+    assert_eq!(stored_timeout, timeout, "Storage should contain the receive library timeout");
+}