@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/endpoint-v2/src/tests/messaging_composer/compose_queue.rs

@@ -0,0 +1,213 @@
+use crate::{tests::endpoint_setup::setup, util::keccak256};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Bytes, BytesN, IntoVal,
+};
+
+#[test]
+fn test_compose_queue_none_initially() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 0u32;
+
+    // Query compose queue before any message is sent
+    let result = endpoint_client.compose_queue(&from, &to, &guid, &index);
+    assert_eq!(result, None);
+}
+
+#[test]
+fn test_compose_queue_after_send() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 0u32;
+    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
+
+    // Send compose
+    env.mock_auths(&[MockAuth {
+        address: &from,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from, &to, &guid, &index, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.send_compose(&from, &to, &guid, &index, &message);
+
+    // Query compose queue
+    let expected_hash = keccak256(env, &message);
+    let result = endpoint_client.compose_queue(&from, &to, &guid, &index);
+    assert_eq!(result, Some(expected_hash));
+}
+
+#[test]
+fn test_compose_queue_different_keys() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from1 = Address::generate(env);
+    let from2 = Address::generate(env);
+    let to1 = Address::generate(env);
+    let to2 = Address::generate(env);
+    let guid1 = BytesN::from_array(env, &[1u8; 32]);
+    let guid2 = BytesN::from_array(env, &[2u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3]);
+
+    // Send compose with from1, to1, guid1, index 0
+    env.mock_auths(&[MockAuth {
+        address: &from1,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from1, &to1, &guid1, &0u32, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.send_compose(&from1, &to1, &guid1, &0, &message);
+
+    let expected_hash = keccak256(env, &message);
+
+    // Query with correct keys
+    assert_eq!(endpoint_client.compose_queue(&from1, &to1, &guid1, &0), Some(expected_hash.clone()));
+
+    // Query with different from
+    assert_eq!(endpoint_client.compose_queue(&from2, &to1, &guid1, &0), None);
+
+    // Query with different to
+    assert_eq!(endpoint_client.compose_queue(&from1, &to2, &guid1, &0), None);
+
+    // Query with different guid
+    assert_eq!(endpoint_client.compose_queue(&from1, &to1, &guid2, &0), None);
+
+    // Query with different index
+    assert_eq!(endpoint_client.compose_queue(&from1, &to1, &guid1, &1), None);
+}
+
+#[test]
+fn test_compose_queue_after_clear() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let composer = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 0u32;
+    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
+
+    // Send compose
+    env.mock_auths(&[MockAuth {
+        address: &from,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from, &composer, &guid, &index, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.send_compose(&from, &composer, &guid, &index, &message);
+
+    // Verify it exists
+    let message_hash = keccak256(env, &message);
+    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &index), Some(message_hash));
+
+    // Clear compose
+    env.mock_auths(&[MockAuth {
+        address: &composer,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "clear_compose",
+            args: (&composer, &from, &guid, &index, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.clear_compose(&composer, &from, &guid, &index, &message);
+
+    // Query compose queue after clear - should be marked as received
+    const RECEIVED_MESSAGE_HASH_BYTES: [u8; 32] =
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
+    let received_hash = BytesN::from_array(env, &RECEIVED_MESSAGE_HASH_BYTES);
+    let result = endpoint_client.compose_queue(&from, &composer, &guid, &index);
+    assert_eq!(result, Some(received_hash));
+}
+
+#[test]
+fn test_compose_queue_multiple_indices() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let message1 = Bytes::from_array(env, &[1, 2, 3]);
+    let message2 = Bytes::from_array(env, &[4, 5, 6]);
+    let message3 = Bytes::from_array(env, &[7, 8, 9]);
+
+    // Send three compose messages with different indices
+    for (idx, msg) in [(0u32, &message1), (1u32, &message2), (2u32, &message3)] {
+        env.mock_auths(&[MockAuth {
+            address: &from,
+            invoke: &MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "send_compose",
+                args: (&from, &to, &guid, &idx, msg).into_val(env),
+                sub_invokes: &[],
+            },
+        }]);
+        endpoint_client.send_compose(&from, &to, &guid, &idx, msg);
+    }
+
+    // Query each index and verify correct hash
+    let hash1 = keccak256(env, &message1);
+    let hash2 = keccak256(env, &message2);
+    let hash3 = keccak256(env, &message3);
+
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &0), Some(hash1));
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &1), Some(hash2));
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &2), Some(hash3));
+
+    // Non-existent index should return None
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &3), None);
+}
+
+#[test]
+fn test_compose_queue_empty_message() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 0u32;
+    let message = Bytes::new(env);
+
+    // Send compose with empty message
+    env.mock_auths(&[MockAuth {
+        address: &from,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from, &to, &guid, &index, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.send_compose(&from, &to, &guid, &index, &message);
+
+    // Query compose queue with empty message
+    let expected_hash = keccak256(env, &message);
+    let result = endpoint_client.compose_queue(&from, &to, &guid, &index);
+    assert_eq!(result, Some(expected_hash));
+}

package/contracts/endpoint-v2/src/tests/messaging_composer/lz_compose_alert.rs

@@ -0,0 +1,269 @@
+use crate::{events::LzComposeAlert, tests::endpoint_setup::setup};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Bytes, BytesN, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_lz_compose_alert_success() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let executor = Address::generate(env);
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 0u32;
+    let gas = 1000i128;
+    let value = 500i128;
+    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
+    let extra_data = Bytes::from_array(env, &[6, 7, 8]);
+    let reason = Bytes::from_array(env, &[9, 10]);
+
+    // Mock auth for executor
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "lz_compose_alert",
+            args: (&executor, &from, &to, &guid, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    endpoint_client.lz_compose_alert(
+        &executor,
+        &from,
+        &to,
+        &guid,
+        &index,
+        &gas,
+        &value,
+        &message,
+        &extra_data,
+        &reason,
+    );
+
+    // Verify the event was published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        LzComposeAlert {
+            from: from.clone(),
+            to: to.clone(),
+            executor: executor.clone(),
+            guid: guid.clone(),
+            index,
+            gas,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        },
+    );
+}
+
+#[test]
+fn test_lz_compose_alert_zero_values() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let executor = Address::generate(env);
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 0u32;
+    let gas = 0i128;
+    let value = 0i128;
+    let message = Bytes::new(env);
+    let extra_data = Bytes::new(env);
+    let reason = Bytes::new(env);
+
+    // Mock auth for executor
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "lz_compose_alert",
+            args: (&executor, &from, &to, &guid, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    endpoint_client.lz_compose_alert(
+        &executor,
+        &from,
+        &to,
+        &guid,
+        &index,
+        &gas,
+        &value,
+        &message,
+        &extra_data,
+        &reason,
+    );
+
+    // Verify the event was published with zero values
+    assert_event(
+        env,
+        &endpoint_client.address,
+        LzComposeAlert {
+            from: from.clone(),
+            to: to.clone(),
+            executor: executor.clone(),
+            guid: guid.clone(),
+            index,
+            gas,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        },
+    );
+}
+
+#[test]
+fn test_lz_compose_alert_large_values() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let executor = Address::generate(env);
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[255u8; 32]);
+    let index = u16::MAX as u32;
+    let gas = i128::MAX;
+    let value = i128::MAX;
+    let message = Bytes::from_array(env, &[255u8; 100]);
+    let extra_data = Bytes::from_array(env, &[128u8; 50]);
+    let reason = Bytes::from_array(env, &[64u8; 25]);
+
+    // Mock auth for executor
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "lz_compose_alert",
+            args: (&executor, &from, &to, &guid, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    endpoint_client.lz_compose_alert(
+        &executor,
+        &from,
+        &to,
+        &guid,
+        &index,
+        &gas,
+        &value,
+        &message,
+        &extra_data,
+        &reason,
+    );
+
+    // Verify the event was published with large values
+    assert_event(
+        env,
+        &endpoint_client.address,
+        LzComposeAlert {
+            from: from.clone(),
+            to: to.clone(),
+            executor: executor.clone(),
+            guid: guid.clone(),
+            index,
+            gas,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        },
+    );
+}
+
+#[test]
+fn test_lz_compose_alert_multiple_alerts() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let executor = Address::generate(env);
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid1 = BytesN::from_array(env, &[1u8; 32]);
+    let guid2 = BytesN::from_array(env, &[2u8; 32]);
+    let index = 0u32;
+    let gas = 1000i128;
+    let value = 500i128;
+    let message = Bytes::from_array(env, &[1, 2, 3]);
+    let extra_data = Bytes::from_array(env, &[4, 5]);
+    let reason = Bytes::from_array(env, &[6]);
+
+    // Send first alert
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "lz_compose_alert",
+            args: (&executor, &from, &to, &guid1, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.lz_compose_alert(
+        &executor,
+        &from,
+        &to,
+        &guid1,
+        &index,
+        &gas,
+        &value,
+        &message,
+        &extra_data,
+        &reason,
+    );
+
+    // Send second alert
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "lz_compose_alert",
+            args: (&executor, &from, &to, &guid2, &index, &gas, &value, &message, &extra_data, &reason).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.lz_compose_alert(
+        &executor,
+        &from,
+        &to,
+        &guid2,
+        &index,
+        &gas,
+        &value,
+        &message,
+        &extra_data,
+        &reason,
+    );
+
+    // Both alerts should succeed - verify at least one event was published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        LzComposeAlert {
+            from: from.clone(),
+            to: to.clone(),
+            executor: executor.clone(),
+            guid: guid2.clone(),
+            index,
+            gas,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        },
+    );
+}

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

@@ -0,0 +1,4 @@
+mod clear_compose;
+mod compose_queue;
+mod lz_compose_alert;
+mod send_compose;

package/contracts/endpoint-v2/src/tests/messaging_composer/send_compose.rs

@@ -0,0 +1,173 @@
+use crate::{events::ComposeSent, storage, tests::endpoint_setup::setup, util::keccak256};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Bytes, BytesN, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_send_compose_success() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 1u32;
+    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
+
+    // Verify initial state - compose queue should not exist
+    let initial_queue = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::compose_queue(env, &from, &to, &guid, index)
+    });
+    assert_eq!(initial_queue, None, "Initial compose queue should be None");
+
+    // Mock auth for 'from' address
+    env.mock_auths(&[MockAuth {
+        address: &from,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from, &to, &guid, &index, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    endpoint_client.send_compose(&from, &to, &guid, &index, &message);
+
+    // Verify the event was published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        ComposeSent { from: from.clone(), to: to.clone(), guid: guid.clone(), index, message: message.clone() },
+    );
+
+    // Verify the compose queue was set via public interface
+    let message_hash = keccak256(env, &message);
+    let stored_hash = endpoint_client.compose_queue(&from, &to, &guid, &index);
+    assert_eq!(stored_hash, Some(message_hash.clone()));
+
+    // Assert storage change directly
+    let stored_hash_direct = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::compose_queue(env, &from, &to, &guid, index)
+    });
+    assert_eq!(stored_hash_direct, Some(message_hash), "Storage should contain the message hash in compose queue");
+}
+
+#[test]
+fn test_send_compose_different_indices() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let message1 = Bytes::from_array(env, &[1, 2, 3]);
+    let message2 = Bytes::from_array(env, &[4, 5, 6]);
+
+    // Send compose with index 0
+    env.mock_auths(&[MockAuth {
+        address: &from,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from, &to, &guid, &0u32, &message1).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.send_compose(&from, &to, &guid, &0, &message1);
+
+    // Send compose with index 1
+    env.mock_auths(&[MockAuth {
+        address: &from,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from, &to, &guid, &1u32, &message2).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.send_compose(&from, &to, &guid, &1, &message2);
+
+    // Verify both compose queues exist
+    let hash1 = keccak256(env, &message1);
+    let hash2 = keccak256(env, &message2);
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &0), Some(hash1));
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &1), Some(hash2));
+}
+
+#[test]
+fn test_send_compose_different_guids() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid1 = BytesN::from_array(env, &[1u8; 32]);
+    let guid2 = BytesN::from_array(env, &[2u8; 32]);
+    let index = 0u32;
+    let message = Bytes::from_array(env, &[1, 2, 3]);
+
+    // Send compose with guid1
+    env.mock_auths(&[MockAuth {
+        address: &from,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from, &to, &guid1, &index, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.send_compose(&from, &to, &guid1, &index, &message);
+
+    // Send compose with guid2
+    env.mock_auths(&[MockAuth {
+        address: &from,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from, &to, &guid2, &index, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.send_compose(&from, &to, &guid2, &index, &message);
+
+    // Verify both compose queues exist
+    let message_hash = keccak256(env, &message);
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid1, &index), Some(message_hash.clone()));
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid2, &index), Some(message_hash));
+}
+
+#[test]
+fn test_send_compose_empty_message() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 0u32;
+    let message = Bytes::new(env);
+
+    // Mock auth for 'from' address
+    env.mock_auths(&[MockAuth {
+        address: &from,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send_compose",
+            args: (&from, &to, &guid, &index, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    endpoint_client.send_compose(&from, &to, &guid, &index, &message);
+
+    // Verify the compose queue was set with empty message hash
+    let message_hash = keccak256(env, &message);
+    let stored_hash = endpoint_client.compose_queue(&from, &to, &guid, &index);
+    assert_eq!(stored_hash, Some(message_hash));
+}