@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/endpoint-v2/src/tests/messaging_channel/outbound_nonce.rs

@@ -0,0 +1,242 @@
+use soroban_sdk::{testutils::Address as _, Address, BytesN};
+
+use crate::{storage, tests::endpoint_setup::setup};
+
+#[test]
+fn test_outbound_nonce_initial_value() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+
+    // Initial outbound nonce should be 0
+    let nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(nonce, 0);
+}
+
+#[test]
+fn test_outbound_nonce_after_setting() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let expected_nonce = 42;
+
+    // Set outbound nonce
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &expected_nonce)
+    });
+
+    // Verify outbound nonce is retrieved correctly
+    let nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(nonce, expected_nonce);
+}
+
+#[test]
+fn test_outbound_nonce_different_senders() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender1 = Address::generate(env);
+    let sender2 = Address::generate(env);
+    let dst_eid = 2;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+
+    // Set different nonces for different senders
+    let nonce1 = 10;
+    let nonce2 = 20;
+
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender1, dst_eid, &receiver, &nonce1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender2, dst_eid, &receiver, &nonce2)
+    });
+
+    // Verify each sender has its own independent nonce
+    let retrieved_nonce1 = endpoint_client.outbound_nonce(&sender1, &dst_eid, &receiver);
+    let retrieved_nonce2 = endpoint_client.outbound_nonce(&sender2, &dst_eid, &receiver);
+
+    assert_eq!(retrieved_nonce1, nonce1);
+    assert_eq!(retrieved_nonce2, nonce2);
+
+    // Verify a third sender still has initial nonce of 0
+    let sender3 = Address::generate(env);
+    let retrieved_nonce3 = endpoint_client.outbound_nonce(&sender3, &dst_eid, &receiver);
+    assert_eq!(retrieved_nonce3, 0);
+}
+
+#[test]
+fn test_outbound_nonce_different_dst_eids() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid1 = 2;
+    let dst_eid2 = 3;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+
+    // Set different nonces for different destination EIDs
+    let nonce1 = 15;
+    let nonce2 = 25;
+
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid1, &receiver, &nonce1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid2, &receiver, &nonce2)
+    });
+
+    // Verify each dst_eid has its own independent nonce
+    let retrieved_nonce1 = endpoint_client.outbound_nonce(&sender, &dst_eid1, &receiver);
+    let retrieved_nonce2 = endpoint_client.outbound_nonce(&sender, &dst_eid2, &receiver);
+
+    assert_eq!(retrieved_nonce1, nonce1);
+    assert_eq!(retrieved_nonce2, nonce2);
+
+    // Verify a third dst_eid still has initial nonce of 0
+    let dst_eid3 = 4;
+    let retrieved_nonce3 = endpoint_client.outbound_nonce(&sender, &dst_eid3, &receiver);
+    assert_eq!(retrieved_nonce3, 0);
+}
+
+#[test]
+fn test_outbound_nonce_different_receivers() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2;
+    let receiver1 = BytesN::from_array(env, &[1u8; 32]);
+    let receiver2 = BytesN::from_array(env, &[2u8; 32]);
+
+    // Set different nonces for different receivers
+    let nonce1 = 30;
+    let nonce2 = 40;
+
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver1, &nonce1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver2, &nonce2)
+    });
+
+    // Verify each receiver has its own independent nonce
+    let retrieved_nonce1 = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver1);
+    let retrieved_nonce2 = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver2);
+
+    assert_eq!(retrieved_nonce1, nonce1);
+    assert_eq!(retrieved_nonce2, nonce2);
+
+    // Verify a third receiver still has initial nonce of 0
+    let receiver3 = BytesN::from_array(env, &[3u8; 32]);
+    let retrieved_nonce3 = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver3);
+    assert_eq!(retrieved_nonce3, 0);
+}
+
+#[test]
+fn test_outbound_nonce_large_values() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+
+    // Test with maximum u64 value
+    let max_nonce = u64::MAX;
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &max_nonce)
+    });
+
+    let retrieved_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(retrieved_nonce, max_nonce);
+
+    // Test with large but not maximum value
+    let large_nonce = u64::MAX - 1000;
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &large_nonce)
+    });
+
+    let retrieved_large_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(retrieved_large_nonce, large_nonce);
+}
+
+#[test]
+fn test_outbound_nonce_incremental_updates() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+
+    // Start with nonce 0
+    let initial_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(initial_nonce, 0);
+
+    // Incrementally update nonce
+    for expected_nonce in 1..=10 {
+        env.as_contract(&endpoint_client.address, || {
+            storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &expected_nonce)
+        });
+
+        let retrieved_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+        assert_eq!(retrieved_nonce, expected_nonce);
+    }
+}
+
+#[test]
+fn test_outbound_nonce_multiple_paths_independence() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender1 = Address::generate(env);
+    let sender2 = Address::generate(env);
+    let dst_eid1 = 2;
+    let dst_eid2 = 3;
+    let receiver1 = BytesN::from_array(env, &[1u8; 32]);
+    let receiver2 = BytesN::from_array(env, &[2u8; 32]);
+
+    // Set nonces for different combinations
+    let nonce_s1_e1_r1 = 100;
+    let nonce_s1_e1_r2 = 200;
+    let nonce_s1_e2_r1 = 300;
+    let nonce_s2_e1_r1 = 400;
+
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender1, dst_eid1, &receiver1, &nonce_s1_e1_r1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender1, dst_eid1, &receiver2, &nonce_s1_e1_r2)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender1, dst_eid2, &receiver1, &nonce_s1_e2_r1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender2, dst_eid1, &receiver1, &nonce_s2_e1_r1)
+    });
+
+    // Verify all paths are independent
+    assert_eq!(endpoint_client.outbound_nonce(&sender1, &dst_eid1, &receiver1), nonce_s1_e1_r1);
+    assert_eq!(endpoint_client.outbound_nonce(&sender1, &dst_eid1, &receiver2), nonce_s1_e1_r2);
+    assert_eq!(endpoint_client.outbound_nonce(&sender1, &dst_eid2, &receiver1), nonce_s1_e2_r1);
+    assert_eq!(endpoint_client.outbound_nonce(&sender2, &dst_eid1, &receiver1), nonce_s2_e1_r1);
+
+    // Verify unset paths still return 0
+    assert_eq!(endpoint_client.outbound_nonce(&sender2, &dst_eid1, &receiver2), 0);
+    assert_eq!(endpoint_client.outbound_nonce(&sender2, &dst_eid2, &receiver1), 0);
+    assert_eq!(endpoint_client.outbound_nonce(&sender2, &dst_eid2, &receiver2), 0);
+}

package/contracts/endpoint-v2/src/tests/messaging_channel/skip.rs

@@ -0,0 +1,232 @@
+use soroban_sdk::{testutils::Address as _, Address, BytesN, IntoVal};
+
+use crate::{events::InboundNonceSkipped, storage, tests::endpoint_setup::setup};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_skip_success() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+
+    // Verify initial state - lazy inbound nonce should be 0
+    let initial_lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
+    });
+    assert_eq!(initial_lazy_nonce, 0, "Initial lazy inbound nonce should be 0");
+
+    // Initially, inbound nonce should be 0
+    let initial_nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(initial_nonce, 0);
+
+    // Skip nonce 1 (expected nonce is initial_nonce + 1 = 1)
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "skip",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .skip(&receiver, &receiver, &src_eid, &sender, &nonce);
+
+    // Verify InboundNonceSkipped event was emitted
+    assert_event(
+        env,
+        &endpoint_client.address,
+        InboundNonceSkipped { src_eid, sender: sender.clone(), receiver: receiver.clone(), nonce },
+    );
+
+    // Verify inbound nonce reflects the skip via public interface
+    let updated_nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(updated_nonce, nonce);
+
+    // Assert storage change directly - lazy inbound nonce was updated
+    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
+    });
+    assert_eq!(lazy_nonce, nonce, "Storage should contain updated lazy inbound nonce");
+}
+
+#[test]
+fn test_skip_multiple_nonces() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Skip nonce 1
+    let nonce1 = 1;
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "skip",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce1).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .skip(&receiver, &receiver, &src_eid, &sender, &nonce1);
+
+    // Skip nonce 2
+    let nonce2 = 2;
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "skip",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce2).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .skip(&receiver, &receiver, &src_eid, &sender, &nonce2);
+
+    // Verify lazy inbound nonce was updated to nonce2
+    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
+    });
+    assert_eq!(lazy_nonce, nonce2);
+
+    // Verify inbound nonce reflects the latest skip
+    let updated_nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(updated_nonce, nonce2);
+}
+
+#[test]
+fn test_skip_with_delegate() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let delegate = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+
+    // Set delegate for receiver
+    env.as_contract(&endpoint_client.address, || storage::EndpointStorage::set_delegate(env, &receiver, &delegate));
+
+    // Delegate can skip on behalf of receiver
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &delegate,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "skip",
+                args: (&delegate, &receiver, &src_eid, &sender, &nonce).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .skip(&delegate, &receiver, &src_eid, &sender, &nonce);
+
+    // Verify InboundNonceSkipped event was emitted
+    assert_event(
+        env,
+        &endpoint_client.address,
+        InboundNonceSkipped { src_eid, sender: sender.clone(), receiver: receiver.clone(), nonce },
+    );
+
+    // Verify lazy inbound nonce was updated
+    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
+    });
+    assert_eq!(lazy_nonce, nonce);
+}
+
+#[test]
+fn test_skip_different_paths() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let receiver1 = Address::generate(env);
+    let receiver2 = Address::generate(env);
+    let src_eid1 = 2;
+    let src_eid2 = 3;
+    let sender1 = BytesN::from_array(env, &[1u8; 32]);
+    let sender2 = BytesN::from_array(env, &[2u8; 32]);
+    let nonce = 1;
+
+    // Skip for different receivers
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver1,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "skip",
+                args: (&receiver1, &receiver1, &src_eid1, &sender1, &nonce).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .skip(&receiver1, &receiver1, &src_eid1, &sender1, &nonce);
+
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver2,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "skip",
+                args: (&receiver2, &receiver2, &src_eid1, &sender1, &nonce).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .skip(&receiver2, &receiver2, &src_eid1, &sender1, &nonce);
+
+    // Skip for different src_eids
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver1,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "skip",
+                args: (&receiver1, &receiver1, &src_eid2, &sender1, &nonce).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .skip(&receiver1, &receiver1, &src_eid2, &sender1, &nonce);
+
+    // Skip for different senders
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver1,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "skip",
+                args: (&receiver1, &receiver1, &src_eid1, &sender2, &nonce).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .skip(&receiver1, &receiver1, &src_eid1, &sender2, &nonce);
+
+    // Verify all paths have independent lazy nonces
+    let lazy_nonce1 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver1, src_eid1, &sender1)
+    });
+    let lazy_nonce2 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver2, src_eid1, &sender1)
+    });
+    let lazy_nonce3 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver1, src_eid2, &sender1)
+    });
+    let lazy_nonce4 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver1, src_eid1, &sender2)
+    });
+
+    assert_eq!(lazy_nonce1, nonce);
+    assert_eq!(lazy_nonce2, nonce);
+    assert_eq!(lazy_nonce3, nonce);
+    assert_eq!(lazy_nonce4, nonce);
+}

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

@@ -0,0 +1,212 @@
+use crate::{events::ComposeDelivered, 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;
+
+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];
+
+#[test]
+fn test_clear_compose_success() {
+    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]);
+
+    // 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);
+
+    // Verify the event was published
+    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");
+}
+
+#[test]
+fn test_clear_compose_multiple_messages() {
+    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 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));
+}
+
+#[test]
+fn test_clear_compose_empty_message() {
+    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);
+
+    // 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));
+}
+
+#[test]
+fn test_clear_compose_sequential_operations() {
+    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, 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);
+
+    // 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));
+}