@layerzerolabs/protocol-stellar-v2 0.2.12 → 0.2.15

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

@@ -1,12 +1,12 @@
 use soroban_sdk::{testutils::Address as _, Address, BytesN};
 
-use crate::{endpoint_v2::EndpointV2, storage, tests::endpoint_setup::setup};
+use crate::{endpoint_v2::EndpointV2, tests::endpoint_setup::setup};
 
 #[test]
 fn test_inbound_payload_hash_not_set() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
@@ -20,9 +20,9 @@ fn test_inbound_payload_hash_not_set() {
 
 #[test]
 fn test_inbound_payload_hash_after_setting() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
@@ -39,278 +39,3 @@ fn test_inbound_payload_hash_after_setting() {
     let payload_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
     assert_eq!(payload_hash, Some(expected_hash));
 }
-
-#[test]
-fn test_inbound_payload_hash_different_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]);
-    let hash1 = BytesN::from_array(env, &[0xabu8; 32]);
-    let hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
-    let hash3 = BytesN::from_array(env, &[0xefu8; 32]);
-
-    // Set payload hashes for different nonces
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 1, &hash1));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 5, &hash2));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 10, &hash3));
-
-    // Verify each nonce has its own independent payload hash
-    let retrieved_hash1 = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &1);
-    let retrieved_hash2 = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &5);
-    let retrieved_hash3 = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &10);
-
-    assert_eq!(retrieved_hash1, Some(hash1));
-    assert_eq!(retrieved_hash2, Some(hash2));
-    assert_eq!(retrieved_hash3, Some(hash3));
-
-    // Verify unset nonces return None
-    let unset_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &2);
-    assert_eq!(unset_hash, None);
-}
-
-#[test]
-fn test_inbound_payload_hash_different_receivers() {
-    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_eid = 2;
-    let sender = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 1;
-    let hash1 = BytesN::from_array(env, &[0xabu8; 32]);
-    let hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
-
-    // Set payload hashes for different receivers
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver1, src_eid, &sender, nonce, &hash1));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver2, src_eid, &sender, nonce, &hash2));
-
-    // Verify each receiver has its own independent payload hash
-    let retrieved_hash1 = endpoint_client.inbound_payload_hash(&receiver1, &src_eid, &sender, &nonce);
-    let retrieved_hash2 = endpoint_client.inbound_payload_hash(&receiver2, &src_eid, &sender, &nonce);
-
-    assert_eq!(retrieved_hash1, Some(hash1));
-    assert_eq!(retrieved_hash2, Some(hash2));
-
-    // Verify a third receiver returns None
-    let receiver3 = Address::generate(env);
-    let unset_hash = endpoint_client.inbound_payload_hash(&receiver3, &src_eid, &sender, &nonce);
-    assert_eq!(unset_hash, None);
-}
-
-#[test]
-fn test_inbound_payload_hash_different_src_eids() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
-
-    let receiver = Address::generate(env);
-    let src_eid1 = 2;
-    let src_eid2 = 3;
-    let sender = BytesN::from_array(env, &[1u8; 32]);
-    let nonce = 1;
-    let hash1 = BytesN::from_array(env, &[0xabu8; 32]);
-    let hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
-
-    // Set payload hashes for different source EIDs
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid1, &sender, nonce, &hash1));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid2, &sender, nonce, &hash2));
-
-    // Verify each src_eid has its own independent payload hash
-    let retrieved_hash1 = endpoint_client.inbound_payload_hash(&receiver, &src_eid1, &sender, &nonce);
-    let retrieved_hash2 = endpoint_client.inbound_payload_hash(&receiver, &src_eid2, &sender, &nonce);
-
-    assert_eq!(retrieved_hash1, Some(hash1));
-    assert_eq!(retrieved_hash2, Some(hash2));
-
-    // Verify a third src_eid returns None
-    let src_eid3 = 4;
-    let unset_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid3, &sender, &nonce);
-    assert_eq!(unset_hash, None);
-}
-
-#[test]
-fn test_inbound_payload_hash_different_senders() {
-    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 sender1 = BytesN::from_array(env, &[1u8; 32]);
-    let sender2 = BytesN::from_array(env, &[2u8; 32]);
-    let nonce = 1;
-    let hash1 = BytesN::from_array(env, &[0xabu8; 32]);
-    let hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
-
-    // Set payload hashes for different senders
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender1, nonce, &hash1));
-    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender2, nonce, &hash2));
-
-    // Verify each sender has its own independent payload hash
-    let retrieved_hash1 = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender1, &nonce);
-    let retrieved_hash2 = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender2, &nonce);
-
-    assert_eq!(retrieved_hash1, Some(hash1));
-    assert_eq!(retrieved_hash2, Some(hash2));
-
-    // Verify a third sender returns None
-    let sender3 = BytesN::from_array(env, &[3u8; 32]);
-    let unset_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender3, &nonce);
-    assert_eq!(unset_hash, None);
-}
-
-#[test]
-fn test_inbound_payload_hash_after_removal() {
-    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;
-    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
-
-    // Set payload hash
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
-    });
-
-    // Verify payload hash is set
-    let retrieved_before = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
-    assert_eq!(retrieved_before, Some(payload_hash));
-
-    // Remove payload hash
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::remove_inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
-    });
-
-    // Verify payload hash is removed
-    let retrieved_after = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
-    assert_eq!(retrieved_after, None);
-}
-
-#[test]
-fn test_inbound_payload_hash_overwrite() {
-    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;
-    let initial_hash = BytesN::from_array(env, &[0xabu8; 32]);
-    let new_hash = BytesN::from_array(env, &[0xcdu8; 32]);
-
-    // Set initial payload hash
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_inbound_payload_hash(env, &receiver, src_eid, &sender, nonce, &initial_hash)
-    });
-
-    let retrieved_initial = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
-    assert_eq!(retrieved_initial, Some(initial_hash));
-
-    // Overwrite with new payload hash
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_inbound_payload_hash(env, &receiver, src_eid, &sender, nonce, &new_hash)
-    });
-
-    let retrieved_new = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
-    assert_eq!(retrieved_new, Some(new_hash));
-}
-
-#[test]
-fn test_inbound_payload_hash_multiple_paths_independence() {
-    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;
-
-    let hash_r1_e1_s1 = BytesN::from_array(env, &[0x11u8; 32]);
-    let hash_r1_e1_s2 = BytesN::from_array(env, &[0x12u8; 32]);
-    let hash_r1_e2_s1 = BytesN::from_array(env, &[0x13u8; 32]);
-    let hash_r2_e1_s1 = BytesN::from_array(env, &[0x14u8; 32]);
-
-    // Set payload hashes for different combinations
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver1, src_eid1, &sender1, nonce, &hash_r1_e1_s1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver1, src_eid1, &sender2, nonce, &hash_r1_e1_s2)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver1, src_eid2, &sender1, nonce, &hash_r1_e2_s1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver2, src_eid1, &sender1, nonce, &hash_r2_e1_s1)
-    });
-
-    // Verify all paths are independent
-    assert_eq!(endpoint_client.inbound_payload_hash(&receiver1, &src_eid1, &sender1, &nonce), Some(hash_r1_e1_s1));
-    assert_eq!(endpoint_client.inbound_payload_hash(&receiver1, &src_eid1, &sender2, &nonce), Some(hash_r1_e1_s2));
-    assert_eq!(endpoint_client.inbound_payload_hash(&receiver1, &src_eid2, &sender1, &nonce), Some(hash_r1_e2_s1));
-    assert_eq!(endpoint_client.inbound_payload_hash(&receiver2, &src_eid1, &sender1, &nonce), Some(hash_r2_e1_s1));
-
-    // Verify unset paths return None
-    assert_eq!(endpoint_client.inbound_payload_hash(&receiver2, &src_eid1, &sender2, &nonce), None);
-    assert_eq!(endpoint_client.inbound_payload_hash(&receiver2, &src_eid2, &sender1, &nonce), None);
-    assert_eq!(endpoint_client.inbound_payload_hash(&receiver2, &src_eid2, &sender2, &nonce), None);
-}
-
-#[test]
-fn test_inbound_payload_hash_zero_hash() {
-    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;
-    let zero_hash = BytesN::from_array(env, &[0u8; 32]);
-
-    // Set zero hash (should be allowed by storage, even though inbound function rejects it)
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_inbound_payload_hash(env, &receiver, src_eid, &sender, nonce, &zero_hash)
-    });
-
-    // Verify zero hash is retrieved correctly
-    let retrieved_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
-    assert_eq!(retrieved_hash, Some(zero_hash));
-}
-
-#[test]
-fn test_inbound_payload_hash_max_hash() {
-    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;
-    let max_hash = BytesN::from_array(env, &[0xffu8; 32]);
-
-    // Set max hash
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_inbound_payload_hash(env, &receiver, src_eid, &sender, nonce, &max_hash)
-    });
-
-    // Verify max hash is retrieved correctly
-    let retrieved_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
-    assert_eq!(retrieved_hash, Some(max_hash));
-}

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

@@ -4,9 +4,9 @@ use crate::{storage, tests::endpoint_setup::setup};
 
 #[test]
 fn test_lazy_inbound_nonce_initial_value() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
@@ -19,9 +19,9 @@ fn test_lazy_inbound_nonce_initial_value() {
 
 #[test]
 fn test_lazy_inbound_nonce_after_setting() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
@@ -37,271 +37,3 @@ fn test_lazy_inbound_nonce_after_setting() {
     let nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
     assert_eq!(nonce, expected_nonce);
 }
-
-#[test]
-fn test_lazy_inbound_nonce_different_receivers() {
-    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_eid = 2;
-    let sender = BytesN::from_array(env, &[1u8; 32]);
-
-    // Set different nonces for different receivers
-    let nonce1 = 10;
-    let nonce2 = 20;
-
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid, &sender, &nonce1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver2, src_eid, &sender, &nonce2)
-    });
-
-    // Verify each receiver has its own independent lazy nonce
-    let retrieved_nonce1 = endpoint_client.lazy_inbound_nonce(&receiver1, &src_eid, &sender);
-    let retrieved_nonce2 = endpoint_client.lazy_inbound_nonce(&receiver2, &src_eid, &sender);
-
-    assert_eq!(retrieved_nonce1, nonce1);
-    assert_eq!(retrieved_nonce2, nonce2);
-
-    // Verify a third receiver still has initial nonce of 0
-    let receiver3 = Address::generate(env);
-    let retrieved_nonce3 = endpoint_client.lazy_inbound_nonce(&receiver3, &src_eid, &sender);
-    assert_eq!(retrieved_nonce3, 0);
-}
-
-#[test]
-fn test_lazy_inbound_nonce_different_src_eids() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
-
-    let receiver = Address::generate(env);
-    let src_eid1 = 2;
-    let src_eid2 = 3;
-    let sender = BytesN::from_array(env, &[1u8; 32]);
-
-    // Set different nonces for different source EIDs
-    let nonce1 = 15;
-    let nonce2 = 25;
-
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid1, &sender, &nonce1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid2, &sender, &nonce2)
-    });
-
-    // Verify each src_eid has its own independent lazy nonce
-    let retrieved_nonce1 = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid1, &sender);
-    let retrieved_nonce2 = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid2, &sender);
-
-    assert_eq!(retrieved_nonce1, nonce1);
-    assert_eq!(retrieved_nonce2, nonce2);
-
-    // Verify a third src_eid still has initial nonce of 0
-    let src_eid3 = 4;
-    let retrieved_nonce3 = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid3, &sender);
-    assert_eq!(retrieved_nonce3, 0);
-}
-
-#[test]
-fn test_lazy_inbound_nonce_different_senders() {
-    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 sender1 = BytesN::from_array(env, &[1u8; 32]);
-    let sender2 = BytesN::from_array(env, &[2u8; 32]);
-
-    // Set different nonces for different senders
-    let nonce1 = 30;
-    let nonce2 = 40;
-
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender1, &nonce1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender2, &nonce2)
-    });
-
-    // Verify each sender has its own independent lazy nonce
-    let retrieved_nonce1 = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender1);
-    let retrieved_nonce2 = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender2);
-
-    assert_eq!(retrieved_nonce1, nonce1);
-    assert_eq!(retrieved_nonce2, nonce2);
-
-    // Verify a third sender still has initial nonce of 0
-    let sender3 = BytesN::from_array(env, &[3u8; 32]);
-    let retrieved_nonce3 = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender3);
-    assert_eq!(retrieved_nonce3, 0);
-}
-
-#[test]
-fn test_lazy_inbound_nonce_large_values() {
-    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]);
-
-    // Test with maximum u64 value
-    let max_nonce = u64::MAX;
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &max_nonce)
-    });
-
-    let retrieved_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
-    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_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &large_nonce)
-    });
-
-    let retrieved_large_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(retrieved_large_nonce, large_nonce);
-}
-
-#[test]
-fn test_lazy_inbound_nonce_incremental_updates() {
-    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]);
-
-    // Start with nonce 0
-    let initial_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(initial_nonce, 0);
-
-    // Incrementally update lazy nonce
-    for expected_nonce in 1..=10 {
-        env.as_contract(&endpoint_client.address, || {
-            storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &expected_nonce)
-        });
-
-        let retrieved_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
-        assert_eq!(retrieved_nonce, expected_nonce);
-    }
-}
-
-#[test]
-fn test_lazy_inbound_nonce_overwrite() {
-    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]);
-
-    // Set initial nonce
-    let initial_nonce = 100;
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &initial_nonce)
-    });
-
-    let retrieved_initial = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(retrieved_initial, initial_nonce);
-
-    // Overwrite with a different nonce
-    let new_nonce = 200;
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &new_nonce)
-    });
-
-    let retrieved_new = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(retrieved_new, new_nonce);
-
-    // Overwrite with a smaller nonce
-    let smaller_nonce = 50;
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &smaller_nonce)
-    });
-
-    let retrieved_smaller = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(retrieved_smaller, smaller_nonce);
-}
-
-#[test]
-fn test_lazy_inbound_nonce_multiple_paths_independence() {
-    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]);
-
-    // Set nonces for different combinations
-    let nonce_r1_e1_s1 = 100;
-    let nonce_r1_e1_s2 = 200;
-    let nonce_r1_e2_s1 = 300;
-    let nonce_r2_e1_s1 = 400;
-
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid1, &sender1, &nonce_r1_e1_s1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid1, &sender2, &nonce_r1_e1_s2)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid2, &sender1, &nonce_r1_e2_s1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver2, src_eid1, &sender1, &nonce_r2_e1_s1)
-    });
-
-    // Verify all paths are independent
-    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver1, &src_eid1, &sender1), nonce_r1_e1_s1);
-    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver1, &src_eid1, &sender2), nonce_r1_e1_s2);
-    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver1, &src_eid2, &sender1), nonce_r1_e2_s1);
-    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver2, &src_eid1, &sender1), nonce_r2_e1_s1);
-
-    // Verify unset paths still return 0
-    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver2, &src_eid1, &sender2), 0);
-    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver2, &src_eid2, &sender1), 0);
-    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver2, &src_eid2, &sender2), 0);
-}
-
-#[test]
-fn test_lazy_inbound_nonce_zero_value() {
-    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]);
-
-    // Set lazy nonce to a non-zero value first
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &50)
-    });
-
-    let non_zero_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(non_zero_nonce, 50);
-
-    // Set lazy nonce back to 0
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &0)
-    });
-
-    let zero_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(zero_nonce, 0);
-}

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

@@ -1,10 +1,11 @@
 mod burn;
-mod clear;
+mod clear_payload;
+mod inbound;
 mod inbound_nonce;
 mod inbound_payload_hash;
-mod internal;
 mod lazy_inbound_nonce;
 mod next_guid;
 mod nilify;
+mod outbound;
 mod outbound_nonce;
 mod skip;