@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

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

@@ -1,13 +1,79 @@
-use crate::{events::ComposeDelivered, storage, tests::endpoint_setup::setup, util::keccak256};
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Bytes, BytesN, IntoVal,
-};
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
 use utils::testing_utils::assert_event;
 
-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];
+use crate::{
+    constants::{MAX_COMPOSE_INDEX, RECEIVED_MESSAGE_HASH_BYTES},
+    errors::EndpointError,
+    events::ComposeDelivered,
+    tests::endpoint_setup::setup,
+    tests::endpoint_setup::TestSetup,
+    util::keccak256,
+};
+
+// Helpers
+fn received_hash(env: &soroban_sdk::Env) -> BytesN<32> {
+    BytesN::from_array(env, &RECEIVED_MESSAGE_HASH_BYTES)
+}
+
+fn clear_compose_with_auth(
+    context: &TestSetup,
+    composer: &Address,
+    from: &Address,
+    guid: &BytesN<32>,
+    index: u32,
+    message: &Bytes,
+) {
+    context.mock_auth(composer, "clear_compose", (composer, from, guid, &index, message));
+    context.endpoint_client.clear_compose(composer, from, guid, &index, message);
+}
+
+fn try_clear_compose_with_auth(
+    context: &TestSetup,
+    composer: &Address,
+    from: &Address,
+    guid: &BytesN<32>,
+    index: u32,
+    message: &Bytes,
+) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+    context.mock_auth(composer, "clear_compose", (composer, from, guid, &index, message));
+    context.endpoint_client.try_clear_compose(composer, from, guid, &index, message)
+}
+
+// Authorization (composer must authorize)
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_clear_compose_requires_composer_auth() {
+    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]);
+
+    // No mock_auth for `composer` -> should panic at `composer.require_auth()`.
+    endpoint_client.clear_compose(&composer, &from, &guid, &index, &message);
+}
+
+// Index bounds (<= MAX_COMPOSE_INDEX)
+#[test]
+fn test_clear_compose_fails_when_index_exceeds_max() {
+    let context = setup();
+    let env = &context.env;
+
+    let from = Address::generate(env);
+    let composer = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3]);
+
+    let invalid_index = MAX_COMPOSE_INDEX + 1;
+    let result = try_clear_compose_with_auth(&context, &composer, &from, &guid, invalid_index, &message);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InvalidIndex.into());
+}
 
+// Successful clear_compose marks compose_queue as RECEIVED and emits ComposeDelivered
 #[test]
 fn test_clear_compose_success() {
     let context = setup();
@@ -20,61 +86,20 @@ fn test_clear_compose_success() {
     let index = 0u32;
     let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
 
-    // First, 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 was stored before clear
-    let message_hash = keccak256(env, &message);
-    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &index), Some(message_hash.clone()));
-
-    // Verify storage before clear
-    let hash_before_clear = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::compose_queue(env, &from, &composer, &guid, index)
-    });
-    assert_eq!(hash_before_clear, Some(message_hash), "Storage should contain message hash before clear");
-
-    // Now 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);
+    context.send_compose_with_auth(&from, &composer, &guid, index, &message);
+    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &index), Some(keccak256(env, &message)));
 
-    // Verify the event was published
+    clear_compose_with_auth(&context, &composer, &from, &guid, index, &message);
     assert_event(
         env,
         &endpoint_client.address,
         ComposeDelivered { from: from.clone(), to: composer.clone(), guid: guid.clone(), index },
     );
-
-    // Verify the compose queue was marked as received via public interface
-    let received_hash = BytesN::from_array(env, &RECEIVED_MESSAGE_HASH_BYTES);
-    let stored_hash = endpoint_client.compose_queue(&from, &composer, &guid, &index);
-    assert_eq!(stored_hash, Some(received_hash.clone()));
-
-    // Assert storage change directly
-    let stored_hash_direct = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::compose_queue(env, &from, &composer, &guid, index)
-    });
-    assert_eq!(stored_hash_direct, Some(received_hash), "Storage should contain received message hash marker");
+    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &index), Some(received_hash(env)));
 }
 
 #[test]
-fn test_clear_compose_multiple_messages() {
+fn test_clear_compose_does_not_affect_other_indices() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
@@ -85,93 +110,50 @@ fn test_clear_compose_multiple_messages() {
     let message1 = Bytes::from_array(env, &[1, 2, 3]);
     let message2 = Bytes::from_array(env, &[4, 5, 6]);
 
-    // Send two compose messages
-    env.mock_auths(&[MockAuth {
-        address: &from,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "send_compose",
-            args: (&from, &composer, &guid, &0u32, &message1).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.send_compose(&from, &composer, &guid, &0, &message1);
-
-    env.mock_auths(&[MockAuth {
-        address: &from,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "send_compose",
-            args: (&from, &composer, &guid, &1u32, &message2).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.send_compose(&from, &composer, &guid, &1, &message2);
-
-    // Clear first message
-    env.mock_auths(&[MockAuth {
-        address: &composer,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "clear_compose",
-            args: (&composer, &from, &guid, &0u32, &message1).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.clear_compose(&composer, &from, &guid, &0, &message1);
-
-    // Verify first message is cleared and second still exists
-    let received_hash = BytesN::from_array(env, &RECEIVED_MESSAGE_HASH_BYTES);
-    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &0), Some(received_hash));
-
-    let hash2 = keccak256(env, &message2);
-    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &1), Some(hash2));
+    context.send_compose_with_auth(&from, &composer, &guid, 0, &message1);
+    context.send_compose_with_auth(&from, &composer, &guid, 1, &message2);
+
+    clear_compose_with_auth(&context, &composer, &from, &guid, 0, &message1);
+    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &0), Some(received_hash(env)));
+    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &1), Some(keccak256(env, &message2)));
 }
 
+// ComposeNotFound cases
 #[test]
-fn test_clear_compose_empty_message() {
+fn test_clear_compose_not_found_when_missing_queue() {
     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::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, &composer, &guid, &index, &message).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.send_compose(&from, &composer, &guid, &index, &message);
-
-    // 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);
+    let message = Bytes::from_array(env, &[1, 2, 3]);
+
+    let result = try_clear_compose_with_auth(&context, &composer, &from, &guid, index, &message);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::ComposeNotFound.into());
+}
+
+#[test]
+fn test_clear_compose_not_found_when_wrong_message() {
+    let context = setup();
+    let env = &context.env;
+
+    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]);
+    let wrong_message = Bytes::from_array(env, &[9, 9, 9]);
 
-    // Verify the compose queue was marked as received
-    let received_hash = BytesN::from_array(env, &RECEIVED_MESSAGE_HASH_BYTES);
-    let stored_hash = endpoint_client.compose_queue(&from, &composer, &guid, &index);
-    assert_eq!(stored_hash, Some(received_hash));
+    context.send_compose_with_auth(&from, &composer, &guid, index, &message);
+
+    let result = try_clear_compose_with_auth(&context, &composer, &from, &guid, index, &wrong_message);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::ComposeNotFound.into());
 }
 
 #[test]
-fn test_clear_compose_sequential_operations() {
+fn test_clear_compose_not_found_when_already_cleared() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
@@ -180,33 +162,40 @@ fn test_clear_compose_sequential_operations() {
     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]);
+    let message = Bytes::from_array(env, &[1, 2, 3]);
 
-    // Send, clear, and verify the flow works correctly
-    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);
-
-    // Clear
-    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);
+    // After a successful clear, the queue is set to RECEIVED marker, so clearing again should fail.
+    context.send_compose_with_auth(&from, &composer, &guid, index, &message);
+    clear_compose_with_auth(&context, &composer, &from, &guid, index, &message);
+    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &index), Some(received_hash(env)));
+
+    let result = try_clear_compose_with_auth(&context, &composer, &from, &guid, index, &message);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::ComposeNotFound.into());
+}
+
+#[test]
+fn test_clear_compose_not_found_when_wrong_composer_and_does_not_mutate() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let composer_a = Address::generate(env);
+    let composer_b = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 0u32;
+    let message = Bytes::from_array(env, &[1, 2, 3]);
+
+    // Queue a compose message for composer_a.
+    context.send_compose_with_auth(&from, &composer_a, &guid, index, &message);
+    assert_eq!(endpoint_client.compose_queue(&from, &composer_a, &guid, &index), Some(keccak256(env, &message)));
+    assert_eq!(endpoint_client.compose_queue(&from, &composer_b, &guid, &index), None);
+
+    // composer_b cannot clear composer_a's queued compose.
+    let result = try_clear_compose_with_auth(&context, &composer_b, &from, &guid, index, &message);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::ComposeNotFound.into());
 
-    // Verify it's marked as received
-    let received_hash = BytesN::from_array(env, &RECEIVED_MESSAGE_HASH_BYTES);
-    assert_eq!(endpoint_client.compose_queue(&from, &composer, &guid, &index), Some(received_hash));
+    // Ensure the failed attempt did not mutate composer_a's queued entry.
+    assert_eq!(endpoint_client.compose_queue(&from, &composer_a, &guid, &index), Some(keccak256(env, &message)));
+    assert_eq!(endpoint_client.compose_queue(&from, &composer_b, &guid, &index), None);
 }

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

@@ -1,9 +1,8 @@
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
+
 use crate::{tests::endpoint_setup::setup, util::keccak256};
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Bytes, BytesN, IntoVal,
-};
 
+// The compose_queue is None when unset
 #[test]
 fn test_compose_queue_none_initially() {
     let context = setup();
@@ -20,6 +19,7 @@ fn test_compose_queue_none_initially() {
     assert_eq!(result, None);
 }
 
+// The compose_queue returns stored message hash after send_compose
 #[test]
 fn test_compose_queue_after_send() {
     let context = setup();
@@ -32,182 +32,9 @@ fn test_compose_queue_after_send() {
     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: &[],
-        },
-    }]);
+    context.mock_auth(&from, "send_compose", (&from, &to, &guid, &index, &message));
     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));
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &index), Some(expected_hash));
 }