@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,10 +1,9 @@
-use crate::{events::DelegateSet, storage, tests::endpoint_setup::setup};
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, IntoVal,
-};
+use soroban_sdk::{testutils::Address as _, Address};
 use utils::testing_utils::assert_event;
 
+use crate::{events::DelegateSet, tests::endpoint_setup::setup};
+
+// Setting delegate (state update + event emission)
 #[test]
 fn test_set_delegate() {
     let context = setup();
@@ -14,30 +13,105 @@ fn test_set_delegate() {
     let oapp = Address::generate(env);
     let delegate = Address::generate(env);
 
-    // Verify initial state - delegate should not be set
-    let initial_delegate = env.as_contract(&endpoint_client.address, || storage::EndpointStorage::delegate(env, &oapp));
+    // Verify initial state - delegate should not be set.
+    let initial_delegate = endpoint_client.delegate(&oapp);
     assert_eq!(initial_delegate, None, "Initial delegate should be None");
 
     let delegate_option = Some(delegate.clone());
-    env.mock_auths(&[MockAuth {
-        address: &oapp,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "set_delegate",
-            args: (&oapp, &delegate_option).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.set_delegate(&oapp, &delegate_option);
+    context.set_delegate_with_auth(&oapp, &delegate_option);
 
-    // Assert event was published
+    // Verify event emission.
     assert_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: Some(delegate.clone()) });
 
-    // Verify delegate via public interface
+    // Verify state update via public interface.
     let actual_delegate = endpoint_client.delegate(&oapp);
     assert_eq!(actual_delegate, Some(delegate.clone()), "Delegate should be set");
+}
+
+#[test]
+fn test_set_delegate_overwrites_existing_delegate() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let delegate_a = Address::generate(env);
+    let delegate_b = Address::generate(env);
+
+    // Set delegate to A.
+    let delegate_a_opt = Some(delegate_a.clone());
+    context.set_delegate_with_auth(&oapp, &delegate_a_opt);
+    assert_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: Some(delegate_a.clone()) });
+    assert_eq!(endpoint_client.delegate(&oapp), Some(delegate_a.clone()));
+
+    // Overwrite delegate with B.
+    let delegate_b_opt = Some(delegate_b.clone());
+    context.set_delegate_with_auth(&oapp, &delegate_b_opt);
+    assert_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: Some(delegate_b.clone()) });
+    assert_eq!(endpoint_client.delegate(&oapp), Some(delegate_b.clone()));
+}
+
+#[test]
+fn test_set_delegate_is_idempotent_for_same_value() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let delegate = Address::generate(env);
+    let delegate_opt = Some(delegate.clone());
+
+    // Setting the same delegate twice should succeed and keep state unchanged.
+    context.set_delegate_with_auth(&oapp, &delegate_opt);
+    context.set_delegate_with_auth(&oapp, &delegate_opt);
+
+    assert_eq!(endpoint_client.delegate(&oapp), Some(delegate.clone()));
+}
 
-    // Assert storage change directly
-    let stored_delegate = env.as_contract(&endpoint_client.address, || storage::EndpointStorage::delegate(env, &oapp));
-    assert_eq!(stored_delegate, Some(delegate.clone()), "Storage should contain the delegate address");
+// Removing delegate (state update + event emission)
+#[test]
+fn test_set_delegate_remove() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let delegate = Address::generate(env);
+
+    // First set a delegate.
+    let delegate_option = Some(delegate.clone());
+    context.set_delegate_with_auth(&oapp, &delegate_option);
+
+    // Verify delegate was set.
+    let stored_delegate = endpoint_client.delegate(&oapp);
+    assert_eq!(stored_delegate, Some(delegate.clone()));
+
+    // Now remove the delegate.
+    let remove_option = None::<Address>;
+    context.set_delegate_with_auth(&oapp, &remove_option);
+
+    // Verify event emission.
+    assert_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: None });
+
+    // Verify state update via public interface.
+    let stored_delegate_after = endpoint_client.delegate(&oapp);
+    assert_eq!(stored_delegate_after, None, "Delegate should be removed");
+}
+
+// Authorization (only oapp)
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_delegate_unauthorized() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let unauthorized_caller = Address::generate(env);
+    let delegate = Address::generate(env);
+
+    let delegate_option = Some(delegate);
+    // Unauthorized caller must not be able to set delegate for an OApp.
+    context.mock_auth(&unauthorized_caller, "set_delegate", (&oapp, &delegate_option));
+    endpoint_client.set_delegate(&oapp, &delegate_option);
 }

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

@@ -1,6 +1,15 @@
-use crate::{events::ZROSet, storage, tests::endpoint_setup::setup};
+use soroban_sdk::{testutils::Address as _, Address};
 use utils::testing_utils::assert_event;
 
+use crate::{events::ZroSet, tests::endpoint_setup::setup, tests::endpoint_setup::TestSetup};
+
+// Helpers
+fn set_zro_with_auth(context: &TestSetup, zro: &Address) {
+    context.mock_owner_auth("set_zro", (zro,));
+    context.endpoint_client.set_zro(zro);
+}
+
+// Success path (state update + event emission)
 #[test]
 fn test_set_zro() {
     let context = setup();
@@ -8,20 +17,63 @@ fn test_set_zro() {
     let endpoint_client = &context.endpoint_client;
 
     // Verify initial state - ZRO should not be set
-    let initial_zro = env.as_contract(&endpoint_client.address, || storage::EndpointStorage::zro(env));
+    let initial_zro = endpoint_client.zro();
     assert_eq!(initial_zro, None, "Initial ZRO should be None");
 
-    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
-    endpoint_client.set_zro(&context.zro_token_client.address);
+    set_zro_with_auth(&context, &context.zro_token_client.address);
 
-    // Assert event was published
-    assert_event(env, &endpoint_client.address, ZROSet { zro: context.zro_token_client.address.clone() });
+    // Verify event emission.
+    assert_event(env, &endpoint_client.address, ZroSet { zro: context.zro_token_client.address.clone() });
 
-    // Verify ZRO token is set via public interface
+    // Verify state update via public interface.
     let zro_token = endpoint_client.zro();
     assert_eq!(zro_token, Some(context.zro_token_client.address.clone()));
+}
+
+#[test]
+fn test_set_zro_overwrites_existing_zro() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Create a second token address to overwrite with.
+    let owner = context.owner.clone();
+    let zro_token_2 = env.register_stellar_asset_contract_v2(owner);
+    let zro_addr_2 = zro_token_2.address();
+
+    // Set ZRO to the first address.
+    set_zro_with_auth(&context, &context.zro_token_client.address);
+    assert_event(env, &endpoint_client.address, ZroSet { zro: context.zro_token_client.address.clone() });
+    assert_eq!(endpoint_client.zro(), Some(context.zro_token_client.address.clone()));
+
+    // Overwrite ZRO with the second address.
+    set_zro_with_auth(&context, &zro_addr_2);
+    assert_event(env, &endpoint_client.address, ZroSet { zro: zro_addr_2.clone() });
+    assert_eq!(endpoint_client.zro(), Some(zro_addr_2));
+}
 
-    // Assert storage change directly
-    let stored_zro = env.as_contract(&endpoint_client.address, || storage::EndpointStorage::zro(env));
-    assert_eq!(stored_zro, Some(context.zro_token_client.address.clone()), "Storage should contain the ZRO address");
+#[test]
+fn test_set_zro_is_idempotent_for_same_value() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    // Setting the same ZRO twice should succeed and keep state unchanged.
+    set_zro_with_auth(&context, &context.zro_token_client.address);
+    set_zro_with_auth(&context, &context.zro_token_client.address);
+
+    assert_eq!(endpoint_client.zro(), Some(context.zro_token_client.address.clone()));
+}
+
+// Authorization (only owner)
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_zro_unauthorized() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let unauthorized = soroban_sdk::Address::generate(env);
+
+    // Unauthorized caller must not be able to set ZRO.
+    context.mock_auth(&unauthorized, "set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
 }

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

@@ -1,7 +1,7 @@
-use crate::tests::endpoint_setup::setup;
 use soroban_sdk::testutils::Address as _;
-use utils::ownable::DefaultOwnableStorage;
+use utils::ownable::OwnableStorage;
 
+use crate::tests::endpoint_setup::setup;
 #[test]
 fn test_transfer_ownership() {
     let context = setup();
@@ -14,7 +14,7 @@ fn test_transfer_ownership() {
     assert_eq!(initial_owner, Some(context.owner.clone()));
 
     // Verify initial owner in storage directly
-    let initial_owner = env.as_contract(&endpoint_client.address, || DefaultOwnableStorage::owner(env));
+    let initial_owner = env.as_contract(&endpoint_client.address, || OwnableStorage::owner(env));
     assert_eq!(initial_owner, Some(context.owner.clone()), "Initial owner should be in storage");
 
     context.mock_owner_auth("transfer_ownership", (&new_owner,));
@@ -25,6 +25,6 @@ fn test_transfer_ownership() {
     assert_eq!(owner, Some(new_owner.clone()));
 
     // Assert storage change directly
-    let stored_owner = env.as_contract(&endpoint_client.address, || DefaultOwnableStorage::owner(env));
+    let stored_owner = env.as_contract(&endpoint_client.address, || OwnableStorage::owner(env));
     assert_eq!(stored_owner, Some(new_owner), "Storage should contain the new owner");
 }

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

@@ -1,10 +1,10 @@
-use crate::tests::endpoint_setup::setup;
 use soroban_sdk::{testutils::Address as _, Address};
 use utils::{
-    errors::TtlError,
-    ttl::{TtlConfig, TtlConfigStorage},
+    errors::TtlConfigurableError,
+    ttl_configurable::{TtlConfig, TtlConfigStorage},
 };
 
+use crate::tests::endpoint_setup::setup;
 fn ttl_defaults(env: &soroban_sdk::Env, contract: &Address) -> (TtlConfig, TtlConfig) {
     env.as_contract(contract, || {
         (
@@ -72,7 +72,7 @@ fn test_panic_set_ttl_configs_invalid_instance_range() {
 
     assert_eq!(
         endpoint.try_set_ttl_configs(&instance_config, &persistent_config).unwrap_err().unwrap(),
-        TtlError::InvalidTtlConfig.into()
+        TtlConfigurableError::InvalidTtlConfig.into()
     );
 }
 
@@ -92,14 +92,11 @@ fn test_panic_set_ttl_configs_exceeds_max_ttl() {
 
     assert_eq!(
         endpoint.try_set_ttl_configs(&instance_config, &persistent_config).unwrap_err().unwrap(),
-        TtlError::InvalidTtlConfig.into()
+        TtlConfigurableError::InvalidTtlConfig.into()
     );
 }
 
-// ============================================================================
 // Frozen TTL Config Tests
-// ============================================================================
-
 #[test]
 fn test_is_ttl_configs_frozen_default_false() {
     let context = setup();
@@ -144,7 +141,7 @@ fn test_freeze_ttl_configs_already_frozen() {
 
     // Try to freeze again
     context.mock_owner_auth("freeze_ttl_configs", ());
-    assert_eq!(endpoint.try_freeze_ttl_configs().unwrap_err().unwrap(), TtlError::TtlConfigAlreadyFrozen.into());
+    assert_eq!(endpoint.try_freeze_ttl_configs().unwrap_err().unwrap(), TtlConfigurableError::TtlConfigAlreadyFrozen.into());
 }
 
 #[test]
@@ -163,7 +160,7 @@ fn test_set_ttl_configs_fails_when_frozen() {
     context.mock_owner_auth("set_ttl_configs", (&instance_config, &persistent_config));
     assert_eq!(
         endpoint.try_set_ttl_configs(&instance_config, &persistent_config).unwrap_err().unwrap(),
-        TtlError::TtlConfigFrozen.into()
+        TtlConfigurableError::TtlConfigFrozen.into()
     );
 }
 
@@ -197,6 +194,6 @@ fn test_set_ttl_configs_then_freeze() {
     context.mock_owner_auth("set_ttl_configs", (&new_instance_config, &persistent_config));
     assert_eq!(
         endpoint.try_set_ttl_configs(&new_instance_config, &persistent_config).unwrap_err().unwrap(),
-        TtlError::TtlConfigFrozen.into()
+        TtlConfigurableError::TtlConfigFrozen.into()
     );
 }

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

@@ -1,59 +1,110 @@
-use crate::{tests::endpoint_setup::setup, Origin};
 use soroban_sdk::{testutils::Address as _, BytesN};
 
+use crate::{tests::endpoint_setup::setup, tests::endpoint_setup::TestSetup, Origin};
+
+fn skip_with_auth(context: &TestSetup, receiver: &soroban_sdk::Address, src_eid: u32, sender: &BytesN<32>, nonce: u64) {
+    // `skip` requires authorization from `caller` (the receiver or its delegate).
+    context.mock_auth(receiver, "skip", (receiver, receiver, &src_eid, sender, &nonce));
+    context.endpoint_client.skip(receiver, receiver, &src_eid, sender, &nonce);
+}
+
+fn verify_with_auth(
+    context: &TestSetup,
+    receive_lib: &soroban_sdk::Address,
+    origin: &Origin,
+    receiver: &soroban_sdk::Address,
+    payload_hash: &BytesN<32>,
+) {
+    // `verify` requires authorization from `receive_lib`.
+    context.mock_auth(receive_lib, "verify", (receive_lib, origin, receiver, payload_hash));
+    context.endpoint_client.verify(receive_lib, origin, receiver, payload_hash);
+}
+
+// New path (lazy nonce == 0) => verifiable when origin.nonce > lazy nonce
 #[test]
-fn test_verifiable_with_new_path() {
+fn test_verifiable_new_path_nonce_1_true() {
     let context = setup();
     let endpoint_client = &context.endpoint_client;
     let receiver = soroban_sdk::Address::generate(&context.env);
-    let src_eid = 2;
+    let src_eid = 2u32;
     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
+    // For a new path (lazy nonce is 0), nonce 1 > 0 should be verifiable.
     let result = endpoint_client.verifiable(&origin, &receiver);
     assert!(result);
 }
 
+// Established path (lazy nonce > 0) => verifiable when origin.nonce > lazy nonce
 #[test]
-fn test_verifiable_with_higher_nonce() {
+fn test_verifiable_after_skip_nonce_gt_lazy_true() {
     let context = setup();
+    let env = &context.env;
     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 };
+    let receiver = soroban_sdk::Address::generate(env);
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Establish the path by skipping nonce 1.
+    skip_with_auth(&context, &receiver, src_eid, &sender, 1);
 
-    // For a new path (lazy nonce is 0), nonce 10 > 0 should be verifiable
+    // 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);
 }
 
+// Nonce <= lazy is still verifiable when inbound payload hash exists
 #[test]
-fn test_verifiable_after_skip() {
+fn test_verifiable_true_when_nonce_leq_lazy_but_payload_hash_exists() {
     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 src_eid = 2u32;
     let sender = BytesN::from_array(env, &[1u8; 32]);
+    let receiver = soroban_sdk::Address::generate(env);
 
-    // 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);
+    // Setup receive library (needed to store a payload hash via verify).
+    let receive_lib = context.setup_default_receive_lib(src_eid, 0);
+
+    // Establish the path by skipping nonce 1 (lazy becomes 1).
+    skip_with_auth(&context, &receiver, src_eid, &sender, 1);
+
+    // Verify nonce 2 (allowed because 2 > lazy 1) which stores inbound payload hash for nonce 2.
+    let origin2 = Origin { src_eid, sender: sender.clone(), nonce: 2u64 };
+    let payload_hash2 = BytesN::from_array(env, &[0x33u8; 32]);
+    verify_with_auth(&context, &receive_lib, &origin2, &receiver, &payload_hash2);
+
+    // Advance lazy nonce to 3 while keeping payload hash for 2 (skip sets lazy nonce only).
+    skip_with_auth(&context, &receiver, src_eid, &sender, 3);
+
+    // Sanity: lazy nonce was advanced, and the payload hash for nonce 2 still exists.
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 3);
+    assert!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &2u64).is_some());
+
+    // Now nonce 2 <= lazy 3, but payload hash exists -> verifiable should be true.
+    assert!(endpoint_client.verifiable(&origin2, &receiver));
 }
 
+// Boundary case (nonce == lazy)
+#[test]
+fn test_verifiable_nonce_eq_lazy_false_without_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 = soroban_sdk::Address::generate(env);
+
+    // Set lazy nonce to 2 without storing any payload hashes.
+    skip_with_auth(&context, &receiver, src_eid, &sender, 1);
+    skip_with_auth(&context, &receiver, src_eid, &sender, 2);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 2);
+
+    // nonce == lazy and payload hash missing -> verifiable should be false.
+    let origin2 = Origin { src_eid, sender: sender.clone(), nonce: 2u64 };
+    assert!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &2u64).is_none());
+    assert!(!endpoint_client.verifiable(&origin2, &receiver));
+}