@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,12 +1,24 @@
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    vec, Address, IntoVal,
+use soroban_sdk::{testutils::Address as _, vec, Address};
+use utils::testing_utils::assert_event;
+
+use crate::{
+    errors::EndpointError, events::SendLibrarySet, storage, tests::endpoint_setup::setup,
+    tests::endpoint_setup::TestSetup, MessageLibType, ResolvedLibrary,
 };
 
-use crate::{errors::EndpointError, events::SendLibrarySet, storage, tests::endpoint_setup::setup, MessageLibType};
-use utils::testing_utils::assert_event;
+// Helpers
+fn try_set_send_library_with_auth(
+    context: &TestSetup,
+    caller: &Address,
+    sender: &Address,
+    dst_eid: u32,
+    new_lib: &Option<Address>,
+) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+    context.mock_auth(caller, "set_send_library", (caller, sender, dst_eid, new_lib));
+    context.endpoint_client.try_set_send_library(caller, sender, &dst_eid, new_lib)
+}
 
-// Tests for set_send_library
+// Authorization (OApp auth required)
 #[test]
 fn test_set_send_library_requires_oapp_auth() {
     let context = setup();
@@ -16,72 +28,105 @@ fn test_set_send_library_requires_oapp_auth() {
     let oapp = Address::generate(env);
     let unauthorized_caller = Address::generate(env);
 
-    // Create and register a valid send lib
+    // Create and register a valid send lib.
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&send_lib);
+
+    // Mock auth for unauthorized caller (not the oapp or its delegate).
+    context.mock_auth(
+        &unauthorized_caller,
+        "set_send_library",
+        (&unauthorized_caller, &oapp, &context.eid, &Some(send_lib.clone())),
+    );
 
-    // Register the library with owner auth
-    context.mock_owner_auth("register_library", (&send_lib,));
-    endpoint_client.register_library(&send_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_send_library",
-            args: (&unauthorized_caller, &oapp, &context.eid, &send_lib).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    // Should fail with Unauthorized error
     let result = endpoint_client.try_set_send_library(&unauthorized_caller, &oapp, &context.eid, &Some(send_lib));
     assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::Unauthorized.into());
 }
 
 #[test]
-fn test_set_send_library_same_value() {
+fn test_set_send_library_allows_delegate() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
     let oapp = Address::generate(env);
+    let delegate = Address::generate(env);
 
-    // Create and register a valid send lib
-    let send_lib_add = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
-    let send_lib = Some(send_lib_add.clone());
-    // Register the library with owner auth
-    context.mock_owner_auth("register_library", (&send_lib_add,));
-    endpoint_client.register_library(&send_lib_add);
-
-    // First set with oapp auth - oapp sets its own send library
-    env.mock_auths(&[MockAuth {
-        address: &oapp,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "set_send_library",
-            args: (&oapp, &oapp, &context.eid, &send_lib).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.set_send_library(&oapp, &oapp, &context.eid, &send_lib);
-
-    // Try to set the same library again with oapp auth
-    env.mock_auths(&[MockAuth {
-        address: &oapp,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "set_send_library",
-            args: (&oapp, &oapp, &context.eid, &send_lib).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    let result = endpoint_client.try_set_send_library(&oapp, &oapp, &context.eid, &send_lib);
+    // Set delegate for the OApp.
+    let delegate_opt = Some(delegate.clone());
+    context.mock_auth(&oapp, "set_delegate", (&oapp, &delegate_opt));
+    endpoint_client.set_delegate(&oapp, &delegate_opt);
 
-    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::SameValue.into());
+    // Create and register a valid send lib.
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&send_lib);
+
+    // Delegate should succeed.
+    context.set_send_library_with_auth(&delegate, &oapp, context.eid, &Some(send_lib.clone()));
+
+    // Verify event emission.
+    assert_event(
+        env,
+        &endpoint_client.address,
+        SendLibrarySet { sender: oapp.clone(), dst_eid: context.eid, new_lib: Some(send_lib.clone()) },
+    );
+
+    // Verify state update via public interface.
+    assert_eq!(
+        endpoint_client.get_send_library(&oapp, &context.eid),
+        ResolvedLibrary { lib: send_lib, is_default: false }
+    );
+}
+
+// Unregistered library rejection
+#[test]
+fn test_set_send_library_unregistered_lib() {
+    let context = setup();
+    let env = &context.env;
+
+    let oapp = Address::generate(env);
+
+    // Create but do not register a valid send lib.
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    let result = try_set_send_library_with_auth(&context, &oapp, &oapp, context.eid, &Some(send_lib));
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlyRegisteredLib.into());
+}
+
+// Wrong library type rejection (must be Send)
+#[test]
+fn test_set_send_library_wrong_lib_type() {
+    let context = setup();
+    let env = &context.env;
+
+    let oapp = Address::generate(env);
+
+    // Create and register a receive-only lib.
+    let receive_lib = context.setup_mock_message_lib(MessageLibType::Receive, vec![env, context.eid]);
+    context.register_library_with_auth(&receive_lib);
+
+    let result = try_set_send_library_with_auth(&context, &oapp, &oapp, context.eid, &Some(receive_lib));
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::OnlySendLib.into());
+}
+
+// Unsupported EID rejection (library must support dst_eid)
+#[test]
+fn test_set_send_library_unsupported_eid() {
+    let context = setup();
+    let env = &context.env;
+
+    let oapp = Address::generate(env);
+    let unsupported_eid = context.eid + 1;
+
+    // Create and register a send lib that only supports `context.eid`.
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&send_lib);
+
+    let result = try_set_send_library_with_auth(&context, &oapp, &oapp, unsupported_eid, &Some(send_lib));
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::UnsupportedEid.into());
 }
 
+// Successful update (state update + event emission)
 #[test]
 fn test_set_send_library_success() {
     let context = setup();
@@ -90,42 +135,171 @@ fn test_set_send_library_success() {
 
     let oapp = Address::generate(env);
 
-    // Create and register a valid send lib
+    // Create and register a valid send lib that supports `context.eid`.
     let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&send_lib);
+
+    // Verify initial state via storage (no public getter for custom send_library).
+    let initial_lib =
+        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::send_library(env, &oapp, context.eid));
+    assert_eq!(initial_lib, None);
 
-    // Register the library with owner auth
-    context.mock_owner_auth("register_library", (&send_lib,));
-    endpoint_client.register_library(&send_lib);
+    // Should succeed.
+    context.set_send_library_with_auth(&oapp, &oapp, context.eid, &Some(send_lib.clone()));
+
+    // Verify event emission.
+    assert_event(
+        env,
+        &endpoint_client.address,
+        SendLibrarySet { sender: oapp.clone(), dst_eid: context.eid, new_lib: Some(send_lib.clone()) },
+    );
 
-    // Verify it was not set
     assert_eq!(
-        env.as_contract(&endpoint_client.address, || storage::EndpointStorage::send_library(env, &oapp, context.eid)),
-        None
+        endpoint_client.get_send_library(&oapp, &context.eid),
+        ResolvedLibrary { lib: send_lib.clone(), is_default: false }
     );
+}
 
-    // Set with oapp auth - oapp sets its own send library
-    env.mock_auths(&[MockAuth {
-        address: &oapp,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "set_send_library",
-            args: (&oapp, &oapp, &context.eid, &send_lib).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+// Successful update with SendAndReceive library type (valid for send)
+#[test]
+fn test_set_send_library_success_with_send_and_receive_type() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
-    endpoint_client.set_send_library(&oapp, &oapp, &context.eid, &Some(send_lib.clone()));
+    let oapp = Address::generate(env);
+
+    // Create and register a SendAndReceive lib that supports `context.eid`.
+    let send_and_receive_lib = context.setup_mock_message_lib(MessageLibType::SendAndReceive, vec![env, context.eid]);
+    context.register_library_with_auth(&send_and_receive_lib);
 
-    // Verify the event was published
+    // Should succeed.
+    context.set_send_library_with_auth(&oapp, &oapp, context.eid, &Some(send_and_receive_lib.clone()));
+
+    // Verify event emission.
     assert_event(
         env,
         &endpoint_client.address,
-        SendLibrarySet { sender: oapp.clone(), dst_eid: context.eid, new_lib: Some(send_lib.clone()) },
+        SendLibrarySet { sender: oapp.clone(), dst_eid: context.eid, new_lib: Some(send_and_receive_lib.clone()) },
     );
 
-    // Verify it was set correctly
+    assert_eq!(
+        endpoint_client.get_send_library(&oapp, &context.eid),
+        ResolvedLibrary { lib: send_and_receive_lib.clone(), is_default: false }
+    );
+}
+
+// Updating from one custom library to another (A -> B)
+#[test]
+fn test_set_send_library_can_change_library() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    let send_lib_a = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    let send_lib_b = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+
+    context.register_library_with_auth(&send_lib_a);
+    context.register_library_with_auth(&send_lib_b);
+
+    // Set A first.
+    context.set_send_library_with_auth(&oapp, &oapp, context.eid, &Some(send_lib_a.clone()));
+    assert_event(
+        env,
+        &endpoint_client.address,
+        SendLibrarySet { sender: oapp.clone(), dst_eid: context.eid, new_lib: Some(send_lib_a.clone()) },
+    );
+    assert_eq!(
+        endpoint_client.get_send_library(&oapp, &context.eid),
+        ResolvedLibrary { lib: send_lib_a.clone(), is_default: false }
+    );
+
+    // Then change to B.
+    context.set_send_library_with_auth(&oapp, &oapp, context.eid, &Some(send_lib_b.clone()));
+    assert_event(
+        env,
+        &endpoint_client.address,
+        SendLibrarySet { sender: oapp.clone(), dst_eid: context.eid, new_lib: Some(send_lib_b.clone()) },
+    );
+    assert_eq!(
+        endpoint_client.get_send_library(&oapp, &context.eid),
+        ResolvedLibrary { lib: send_lib_b.clone(), is_default: false }
+    );
+}
+
+// Same value rejection (no-op is not allowed)
+#[test]
+fn test_set_send_library_same_value() {
+    let context = setup();
+    let env = &context.env;
+
+    let oapp = Address::generate(env);
+
+    // Create and register a valid send lib that supports `context.eid`.
+    let send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&send_lib);
+
+    context.set_send_library_with_auth(&oapp, &oapp, context.eid, &Some(send_lib.clone()));
+
+    let result = try_set_send_library_with_auth(&context, &oapp, &oapp, context.eid, &Some(send_lib));
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::SameValue.into());
+}
+
+#[test]
+fn test_set_send_library_none_when_already_none() {
+    let context = setup();
+    let env = &context.env;
+
+    let oapp = Address::generate(env);
+
+    let result = try_set_send_library_with_auth(&context, &oapp, &oapp, context.eid, &None);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::SameValue.into());
+}
+
+// Clearing to None falls back to the default send library
+#[test]
+fn test_set_send_library_clear_to_none_falls_back_to_default() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    // Set up a default send library first so `get_send_library` can resolve the default.
+    let (default_send_lib, _fee_recipient) = context.setup_default_send_lib(context.eid, 1i128, 0i128);
+    assert_eq!(endpoint_client.default_send_library(&context.eid), Some(default_send_lib.clone()));
+
+    // Create and register a valid send lib that supports `context.eid`.
+    let custom_send_lib = context.setup_mock_message_lib(MessageLibType::Send, vec![env, context.eid]);
+    context.register_library_with_auth(&custom_send_lib);
+
+    // Set a custom library.
+    context.set_send_library_with_auth(&oapp, &oapp, context.eid, &Some(custom_send_lib.clone()));
+    assert_event(
+        env,
+        &endpoint_client.address,
+        SendLibrarySet { sender: oapp.clone(), dst_eid: context.eid, new_lib: Some(custom_send_lib.clone()) },
+    );
+    assert_eq!(
+        endpoint_client.get_send_library(&oapp, &context.eid),
+        ResolvedLibrary { lib: custom_send_lib.clone(), is_default: false }
+    );
+
+    // Then clear to None (should fall back to default).
+    context.set_send_library_with_auth(&oapp, &oapp, context.eid, &None);
+    assert_event(
+        env,
+        &endpoint_client.address,
+        SendLibrarySet { sender: oapp.clone(), dst_eid: context.eid, new_lib: None },
+    );
     assert_eq!(
         env.as_contract(&endpoint_client.address, || storage::EndpointStorage::send_library(env, &oapp, context.eid)),
-        Some(send_lib)
+        None
+    );
+    assert_eq!(
+        endpoint_client.get_send_library(&oapp, &context.eid),
+        ResolvedLibrary { lib: default_send_lib, is_default: true }
     );
 }

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

@@ -0,0 +1,102 @@
+use soroban_sdk::{
+    testutils::{Address as _, Ledger},
+    Address, Env,
+};
+
+use crate::Timeout;
+// Timeout::is_expired()
+#[test]
+fn test_timeout_is_expired_when_expiry_equals_current_timestamp() {
+    let env = Env::default();
+    let current_timestamp = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let timeout = Timeout { lib: Address::generate(&env), expiry: current_timestamp };
+
+    // When expiry equals current timestamp, it should be considered expired
+    assert!(timeout.is_expired(&env));
+}
+
+#[test]
+fn test_timeout_is_expired_when_expiry_before_current_timestamp() {
+    let env = Env::default();
+    let current_timestamp = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let timeout = Timeout { lib: Address::generate(&env), expiry: current_timestamp - 1 };
+
+    // When expiry is before current timestamp, it should be expired
+    assert!(timeout.is_expired(&env));
+}
+
+#[test]
+fn test_timeout_is_not_expired_when_expiry_after_current_timestamp() {
+    let env = Env::default();
+    let current_timestamp = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let timeout = Timeout { lib: Address::generate(&env), expiry: current_timestamp + 1 };
+
+    // When expiry is after current timestamp, it should not be expired
+    assert!(!timeout.is_expired(&env));
+}
+
+// Timeout::is_valid_for()
+#[test]
+fn test_timeout_is_valid_for_matching_library_and_not_expired() {
+    let env = Env::default();
+    let current_timestamp = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let lib = Address::generate(&env);
+    let timeout = Timeout { lib: lib.clone(), expiry: current_timestamp + 1000 };
+
+    // Should be valid: library matches and not expired
+    assert!(timeout.is_valid_for(&env, &lib));
+}
+
+#[test]
+fn test_timeout_is_not_valid_for_different_library() {
+    let env = Env::default();
+    let current_timestamp = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let lib_a = Address::generate(&env);
+    let lib_b = Address::generate(&env);
+    let timeout = Timeout { lib: lib_a.clone(), expiry: current_timestamp + 1000 };
+
+    // Should not be valid: library doesn't match
+    assert!(!timeout.is_valid_for(&env, &lib_b));
+}
+
+#[test]
+fn test_timeout_is_not_valid_when_expired() {
+    let env = Env::default();
+    let current_timestamp = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let lib = Address::generate(&env);
+    let timeout = Timeout {
+        lib: lib.clone(),
+        expiry: current_timestamp - 1, // Already expired
+    };
+
+    // Should not be valid: expired even though library matches
+    assert!(!timeout.is_valid_for(&env, &lib));
+}
+
+#[test]
+fn test_timeout_is_not_valid_when_expired_at_current_timestamp() {
+    let env = Env::default();
+    let current_timestamp = 1_700_000_000u64;
+    env.ledger().with_mut(|li| li.timestamp = current_timestamp);
+
+    let lib = Address::generate(&env);
+    let timeout = Timeout {
+        lib: lib.clone(),
+        expiry: current_timestamp, // Expires exactly at current timestamp
+    };
+
+    // Should not be valid: expired (expiry <= current_timestamp)
+    assert!(!timeout.is_valid_for(&env, &lib));
+}