@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,3 +1,5 @@
+use soroban_sdk::BytesN;
+
 use crate::{
     tests::{
         endpoint_setup::setup,
@@ -5,72 +7,59 @@ use crate::{
     },
     Origin,
 };
-use soroban_sdk::BytesN;
 
+// New path initialization is gated by receiver.allow_initialize_path(...)
 #[test]
-fn test_initializable_with_receiver_allowing_init() {
+fn test_initializable_new_path_receiver_allows() {
     let context = setup();
     let endpoint_client = &context.endpoint_client;
 
-    // Deploy mock receiver that allows initialization
+    // Deploy mock receiver that allows initialization.
     let receiver = context.env.register(MockReceiver, ());
-    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), should depend on receiver contract
-    // MockReceiver allows initialization, so this should return true
+    // For a new path (lazy nonce is 0), initializable depends on receiver contract.
     let result = endpoint_client.initializable(&origin, &receiver);
     assert!(result);
 }
 
 #[test]
-fn test_initializable_with_receiver_rejecting_init() {
+fn test_initializable_new_path_receiver_rejects() {
     let context = setup();
     let endpoint_client = &context.endpoint_client;
 
-    // Deploy mock receiver that rejects initialization
+    // Deploy mock receiver that rejects initialization.
     let receiver = context.env.register(MockReceiverReject, ());
-    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), should depend on receiver contract
-    // MockReceiverReject rejects initialization, so this should return false
+    // For a new path (lazy nonce is 0), initializable depends on receiver contract.
     let result = endpoint_client.initializable(&origin, &receiver);
     assert!(!result);
 }
 
+// Established paths always return true (lazy nonce > 0)
 #[test]
-fn test_initializable_with_established_path() {
+fn test_initializable_established_path_always_true() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    // Deploy mock receiver that rejects initialization
+    // Deploy mock receiver that rejects initialization.
     let receiver = env.register(MockReceiverReject, ());
-    let src_eid = 2;
+    let src_eid = 2u32;
     let sender = BytesN::from_array(env, &[1u8; 32]);
 
-    // First establish the path by skipping nonce 1
-    let _origin = Origin { src_eid, sender: sender.clone(), nonce: 1 };
-    
-    // Set up auth for skip (receiver must authorize)
-    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);
+    // Establish the path by skipping nonce 1.
+    let nonce = 1u64;
+    context.mock_auth(&receiver, "skip", (&receiver, &receiver, &src_eid, &sender, &nonce));
+    context.endpoint_client.skip(&receiver, &receiver, &src_eid, &sender, &nonce);
 
-    // Now the path is established (lazy_nonce > 0), should return true regardless of receiver
+    // Now the path is established (lazy_nonce > 0), it should return true regardless of receiver.
     let origin2 = Origin { src_eid, sender, nonce: 2 };
     let result = endpoint_client.initializable(&origin2, &receiver);
     assert!(result);
 }
-

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

@@ -1,211 +1,173 @@
-use crate::{events::LzReceiveAlert, tests::endpoint_setup::setup, Origin};
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Bytes, BytesN, IntoVal,
-};
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
 use utils::testing_utils::assert_event;
 
-#[test]
-fn test_lz_receive_alert_auth() {
-    let context = setup();
-    let env = &context.env;
-    let endpoint_client = &context.endpoint_client;
+use crate::{
+    endpoint_v2::EndpointV2Client, events::LzReceiveAlert, tests::endpoint_setup::setup,
+    tests::endpoint_setup::TestSetup, Origin,
+};
+
+// Helpers
+struct LzReceiveAlertFixture {
+    executor: Address,
+    receiver: Address,
+    origin: Origin,
+    guid: BytesN<32>,
+    gas: i128,
+    value: i128,
+    message: Bytes,
+    extra_data: Bytes,
+    reason: Bytes,
+}
 
+fn default_fixture(env: &Env) -> LzReceiveAlertFixture {
     let executor = soroban_sdk::Address::generate(env);
     let receiver = soroban_sdk::Address::generate(env);
+
     let src_eid = 2u32;
     let sender = BytesN::from_array(env, &[1u8; 32]);
     let nonce = 1u64;
-    let guid = BytesN::from_array(env, &[5u8; 32]);
-    let gas = 1000i128;
-    let value = 100i128;
-    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
-    let extra_data = Bytes::from_array(env, &[5, 6]);
-    let reason = Bytes::from_array(env, &[7, 8, 9]);
-
     let origin = Origin { src_eid, sender, nonce };
 
-    // Mock auth for executor - test that the function requires auth from executor
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "lz_receive_alert",
-            args: (&executor, &origin, &receiver, &guid, &gas, &value, &message, &extra_data, &reason).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+    LzReceiveAlertFixture {
+        executor,
+        receiver,
+        origin,
+        guid: BytesN::from_array(env, &[5u8; 32]),
+        gas: 1000i128,
+        value: 100i128,
+        message: Bytes::from_array(env, &[1, 2, 3, 4]),
+        extra_data: Bytes::from_array(env, &[5, 6]),
+        reason: Bytes::from_array(env, &[7, 8, 9]),
+    }
+}
 
-    // This should not panic if auth is correct
-    endpoint_client.lz_receive_alert(
-        &executor,
-        &origin,
-        &receiver,
-        &guid,
-        &gas,
-        &value,
-        &message,
-        &extra_data,
-        &reason,
+fn invoke_lz_receive_alert_with_auth<'a>(
+    context: &TestSetup,
+    endpoint_client: &EndpointV2Client<'a>,
+    executor: &Address,
+    origin: &Origin,
+    receiver: &Address,
+    guid: &BytesN<32>,
+    gas: i128,
+    value: i128,
+    message: &Bytes,
+    extra_data: &Bytes,
+    reason: &Bytes,
+) {
+    // The endpoint requires authorization from `executor`.
+    context.mock_auth(
+        executor,
+        "lz_receive_alert",
+        (executor, origin, receiver, guid, &gas, &value, message, extra_data, reason),
     );
 
-    // Verify LzReceiveAlert event was published
-    assert_event(
-        env,
-        &endpoint_client.address,
-        LzReceiveAlert {
-            receiver: receiver.clone(),
-            executor: executor.clone(),
-            origin: origin.clone(),
-            guid: guid.clone(),
-            gas,
-            value,
-            message: message.clone(),
-            extra_data: extra_data.clone(),
-            reason: reason.clone(),
-        },
-    );
+    endpoint_client.lz_receive_alert(executor, origin, receiver, guid, &gas, &value, message, extra_data, reason);
 }
 
+// Authorization (executor must authorize)
 #[test]
-fn test_lz_receive_alert_with_empty_data() {
+fn test_lz_receive_alert_auth() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    let executor = soroban_sdk::Address::generate(env);
-    let receiver = soroban_sdk::Address::generate(env);
-    let src_eid = 2u32;
-    let sender = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 1u64;
-    let guid = BytesN::from_array(env, &[5u8; 32]);
-    let gas = 0i128;
-    let value = 0i128;
-    let message = Bytes::new(env);
-    let extra_data = Bytes::new(env);
-    let reason = Bytes::new(env);
-
-    let origin = Origin { src_eid, sender, nonce };
-
-    // Mock auth for executor
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "lz_receive_alert",
-            args: (&executor, &origin, &receiver, &guid, &gas, &value, &message, &extra_data, &reason).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    // This should not panic
-    endpoint_client.lz_receive_alert(
-        &executor,
-        &origin,
-        &receiver,
-        &guid,
-        &gas,
-        &value,
-        &message,
-        &extra_data,
-        &reason,
+    let f = default_fixture(env);
+
+    invoke_lz_receive_alert_with_auth(
+        &context,
+        endpoint_client,
+        &f.executor,
+        &f.origin,
+        &f.receiver,
+        &f.guid,
+        f.gas,
+        f.value,
+        &f.message,
+        &f.extra_data,
+        &f.reason,
     );
 
-    // Verify LzReceiveAlert event was published with empty data
     assert_event(
         env,
         &endpoint_client.address,
         LzReceiveAlert {
-            receiver: receiver.clone(),
-            executor: executor.clone(),
-            origin: origin.clone(),
-            guid: guid.clone(),
-            gas,
-            value,
-            message: message.clone(),
-            extra_data: extra_data.clone(),
-            reason: reason.clone(),
+            receiver: f.receiver.clone(),
+            executor: f.executor.clone(),
+            origin: f.origin.clone(),
+            guid: f.guid.clone(),
+            gas: f.gas,
+            value: f.value,
+            message: f.message.clone(),
+            extra_data: f.extra_data.clone(),
+            reason: f.reason.clone(),
         },
     );
 }
 
 #[test]
-fn test_lz_receive_alert_with_different_origins() {
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_lz_receive_alert_fails_without_executor_auth() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
-    let executor = soroban_sdk::Address::generate(env);
-    let receiver = soroban_sdk::Address::generate(env);
-    let src_eid = 2u32;
-    let sender = BytesN::from_array(env, &[1u8; 32]);
-    let guid = BytesN::from_array(env, &[5u8; 32]);
-    let gas = 1000i128;
-    let value = 100i128;
-    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
-    let extra_data = Bytes::from_array(env, &[5, 6]);
-    let reason = Bytes::from_array(env, &[7, 8, 9]);
-
-    // Call with nonce 1
-    let origin1 = Origin { src_eid, sender: sender.clone(), nonce: 1 };
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "lz_receive_alert",
-            args: (&executor, &origin1, &receiver, &guid, &gas, &value, &message, &extra_data, &reason).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+    let f = default_fixture(env);
+
+    // Calling without `env.mock_auths(...)` should fail because `executor.require_auth()` is enforced.
     endpoint_client.lz_receive_alert(
-        &executor,
-        &origin1,
-        &receiver,
-        &guid,
-        &gas,
-        &value,
-        &message,
-        &extra_data,
-        &reason,
+        &f.executor,
+        &f.origin,
+        &f.receiver,
+        &f.guid,
+        &f.gas,
+        &f.value,
+        &f.message,
+        &f.extra_data,
+        &f.reason,
     );
+}
 
-    // Call with nonce 2 should also succeed
-    let origin2 = Origin { src_eid, sender, nonce: 2 };
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "lz_receive_alert",
-            args: (&executor, &origin2, &receiver, &guid, &gas, &value, &message, &extra_data, &reason).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.lz_receive_alert(
-        &executor,
-        &origin2,
-        &receiver,
-        &guid,
-        &gas,
-        &value,
-        &message,
-        &extra_data,
-        &reason,
+// Payload edge cases
+#[test]
+fn test_lz_receive_alert_with_empty_data() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let mut f = default_fixture(env);
+    f.gas = 0;
+    f.value = 0;
+    f.message = Bytes::new(env);
+    f.extra_data = Bytes::new(env);
+    f.reason = Bytes::new(env);
+
+    invoke_lz_receive_alert_with_auth(
+        &context,
+        endpoint_client,
+        &f.executor,
+        &f.origin,
+        &f.receiver,
+        &f.guid,
+        f.gas,
+        f.value,
+        &f.message,
+        &f.extra_data,
+        &f.reason,
     );
 
-    // Verify LzReceiveAlert events were published for both calls
     assert_event(
         env,
         &endpoint_client.address,
         LzReceiveAlert {
-            receiver: receiver.clone(),
-            executor: executor.clone(),
-            origin: origin2.clone(),
-            guid: guid.clone(),
-            gas,
-            value,
-            message: message.clone(),
-            extra_data: extra_data.clone(),
-            reason: reason.clone(),
+            receiver: f.receiver.clone(),
+            executor: f.executor.clone(),
+            origin: f.origin.clone(),
+            guid: f.guid.clone(),
+            gas: f.gas,
+            value: f.value,
+            message: f.message.clone(),
+            extra_data: f.extra_data.clone(),
+            reason: f.reason.clone(),
         },
     );
 }

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

@@ -1,3 +1,4 @@
+mod build_outbound_packet;
 mod clear;
 mod delegate;
 mod initializable;

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

@@ -1,5 +1,4 @@
 use crate::tests::endpoint_setup::setup;
-
 #[test]
 fn test_native_token() {
     let context = setup();

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

@@ -1,5 +1,4 @@
 use crate::tests::endpoint_setup::setup;
-
 #[test]
 fn test_owner() {
     let context = setup();