@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

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

@@ -0,0 +1,203 @@
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
+
+use crate::{
+    endpoint_v2::EndpointV2,
+    storage,
+    tests::endpoint_setup::{setup, TestSetup},
+};
+
+// Helpers
+fn inbound_as_verified_from_payload(
+    context: &TestSetup,
+    receiver: &Address,
+    src_eid: u32,
+    sender: &BytesN<32>,
+    nonce: u64,
+    payload: &Bytes,
+) -> BytesN<32> {
+    let env = &context.env;
+    let payload_hash = BytesN::from_array(env, &env.crypto().keccak256(payload).to_array());
+    context.inbound_as_verified(receiver, src_eid, sender, nonce, &payload_hash);
+    payload_hash
+}
+
+fn clear_payload(
+    context: &TestSetup,
+    receiver: &Address,
+    src_eid: u32,
+    sender: &BytesN<32>,
+    nonce: u64,
+    payload: &Bytes,
+) {
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, receiver, src_eid, sender, nonce, payload)
+    });
+}
+
+// Internal clear_payload() removes verified payload and advances lazy nonce
+#[test]
+fn test_clear_payload_success() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1u64;
+    let payload = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+
+    let payload_hash = inbound_as_verified_from_payload(&context, &receiver, src_eid, &sender, nonce, &payload);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), Some(payload_hash.clone()));
+
+    clear_payload(&context, &receiver, src_eid, &sender, nonce, &payload);
+
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), None);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), nonce);
+}
+
+#[test]
+fn test_clear_payload_with_lazy_nonce_update_skipping_intermediate() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    let payload1 = Bytes::from_array(env, &[0x01]);
+    let payload2 = Bytes::from_array(env, &[0x02]);
+    let payload3 = Bytes::from_array(env, &[0x03]);
+
+    let hash1 = inbound_as_verified_from_payload(&context, &receiver, src_eid, &sender, 1, &payload1);
+    let hash2 = inbound_as_verified_from_payload(&context, &receiver, src_eid, &sender, 2, &payload2);
+    let hash3 = inbound_as_verified_from_payload(&context, &receiver, src_eid, &sender, 3, &payload3);
+
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 0);
+
+    // Clearing nonce 3 advances lazy nonce from 0 -> 3, but only if 1..=3 all exist.
+    clear_payload(&context, &receiver, src_eid, &sender, 3, &payload3);
+
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 3);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &3), None);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &1), Some(hash1));
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &2), Some(hash2));
+    let _ = hash3; // hash3 is only used to ensure it was computed and stored for nonce 3.
+}
+
+// Clearing a nonce <= lazy nonce does not update lazy nonce
+#[test]
+fn test_clear_payload_does_not_update_lazy_nonce_when_nonce_is_not_greater() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Pretend we already checkpointed to 5.
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &5u64)
+    });
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 5);
+
+    // Store a payload hash at nonce 3, then clear it.
+    let nonce = 3u64;
+    let payload = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+    let payload_hash = inbound_as_verified_from_payload(&context, &receiver, src_eid, &sender, nonce, &payload);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), Some(payload_hash));
+
+    clear_payload(&context, &receiver, src_eid, &sender, nonce, &payload);
+
+    // Clearing an older nonce should not mutate lazy_inbound_nonce.
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 5);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), None);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #19)")] // EndpointError::PayloadHashNotFound
+fn test_clear_payload_payload_hash_not_found_when_nonce_is_checkpointed_but_missing() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // nonce <= lazy_nonce, so clear_payload will NOT run the "has_payload for all intermediate nonces" check.
+    // It should fail at the payload hash check instead.
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &5u64)
+    });
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 5);
+
+    // No payload hash is stored for nonce 3.
+    let nonce = 3u64;
+    let payload = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+    clear_payload(&context, &receiver, src_eid, &sender, nonce, &payload);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #19)")] // EndpointError::PayloadHashNotFound
+fn test_clear_payload_wrong_payload() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+
+    let payload = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+    let wrong_payload = Bytes::from_array(env, &[0xdd, 0xee, 0xff]);
+
+    let payload_hash = inbound_as_verified_from_payload(&context, &receiver, src_eid, &sender, nonce, &payload);
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), Some(payload_hash));
+
+    clear_payload(&context, &receiver, src_eid, &sender, nonce, &wrong_payload);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #10)")] // EndpointError::InvalidNonce
+fn test_clear_payload_not_stored() {
+    let context = setup();
+    let env = &context.env;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let payload = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+
+    clear_payload(&context, &receiver, src_eid, &sender, nonce, &payload);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #10)")] // EndpointError::InvalidNonce
+fn test_clear_payload_missing_intermediate_nonce() {
+    let context = setup();
+    let env = &context.env;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Store only nonce 1 and 3, skip nonce 2
+    let payload1 = Bytes::from_array(env, &[0x01]);
+    let payload3 = Bytes::from_array(env, &[0x03]);
+
+    let _ = inbound_as_verified_from_payload(&context, &receiver, src_eid, &sender, 1, &payload1);
+    let _ = inbound_as_verified_from_payload(&context, &receiver, src_eid, &sender, 3, &payload3);
+
+    // Clearing nonce 1 advances lazy nonce from 0 -> 1.
+    clear_payload(&context, &receiver, src_eid, &sender, 1, &payload1);
+
+    // Try to clear nonce 3 - should panic because nonce 2 is missing
+    clear_payload(&context, &receiver, src_eid, &sender, 3, &payload3);
+}

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

@@ -0,0 +1,94 @@
+use soroban_sdk::{testutils::Address as _, Address, BytesN};
+
+use crate::{endpoint_v2::EndpointV2, tests::endpoint_setup::setup};
+
+// Internal inbound() stores payload hash per nonce and rejects empty payload hash
+#[test]
+fn test_inbound_success_stores_payload_hash() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.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]); // Valid non-empty payload hash
+
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+    });
+
+    let stored_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
+    assert_eq!(stored_hash, Some(payload_hash.clone()));
+
+    // Different nonce for same path
+    let nonce2 = 2;
+    let payload_hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce2, &payload_hash2)
+    });
+    assert_eq!(
+        endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce2),
+        Some(payload_hash2.clone())
+    );
+
+    // Different receiver should have independent storage
+    let different_receiver = Address::generate(env);
+    let payload_hash3 = BytesN::from_array(env, &[0xefu8; 32]);
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &different_receiver, src_eid, &sender, nonce, &payload_hash3)
+    });
+    assert_eq!(
+        endpoint_client.inbound_payload_hash(&different_receiver, &src_eid, &sender, &nonce),
+        Some(payload_hash3)
+    );
+}
+
+// Inbound() overwrites payload hash for the same (receiver, src_eid, sender, nonce)
+#[test]
+fn test_inbound_overwrites_same_nonce() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.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_a = BytesN::from_array(env, &[0xabu8; 32]);
+    let payload_hash_b = BytesN::from_array(env, &[0xcdu8; 32]);
+
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash_a)
+    });
+    assert_eq!(
+        endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce),
+        Some(payload_hash_a.clone())
+    );
+
+    // Overwrite the same nonce with a different payload hash.
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash_b)
+    });
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce), Some(payload_hash_b));
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11)")] // EndpointError::InvalidPayloadHash
+fn test_inbound_rejects_empty_payload_hash() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let empty_hash = BytesN::from_array(env, &[0u8; 32]); // empty payload hash is invalid for inbound()
+
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &empty_hash)
+    });
+}

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

@@ -1,288 +1,118 @@
 use soroban_sdk::{testutils::Address as _, Address, BytesN};
 
-use crate::{endpoint_v2::EndpointV2, storage, tests::endpoint_setup::setup};
-
-#[test]
-fn test_inbound_nonce_initial_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]);
-
-    // Initial inbound nonce should be 0 (lazy nonce is 0, no payload hashes)
-    let nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(nonce, 0);
+use crate::tests::endpoint_setup::{setup, TestSetup};
+
+// Helpers
+fn inbound_as_verified_with_fixed_hash(
+    context: &TestSetup,
+    receiver: &Address,
+    src_eid: u32,
+    sender: &BytesN<32>,
+    nonce: u64,
+) {
+    let payload_hash = BytesN::from_array(&context.env, &[0xabu8; 32]);
+    context.inbound_as_verified(receiver, src_eid, sender, nonce, &payload_hash);
 }
 
+// Initial value
 #[test]
-fn test_inbound_nonce_with_lazy_nonce_only() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+fn test_inbound_nonce_initially_zero() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
     let sender = BytesN::from_array(env, &[1u8; 32]);
-    let lazy_nonce = 5;
 
-    // Set lazy nonce without any payload hashes
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &lazy_nonce)
-    });
-
-    // Inbound nonce should equal lazy nonce when no payload hashes exist
-    let nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(nonce, lazy_nonce);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 0);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 0);
 }
 
+// Lazy nonce is the baseline when there are no consecutive payload hashes
 #[test]
-fn test_inbound_nonce_with_consecutive_payload_hashes() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+fn test_inbound_nonce_equals_lazy_nonce_when_no_payload_hashes() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
     let sender = BytesN::from_array(env, &[1u8; 32]);
-    let lazy_nonce = 2;
-
-    // Set lazy nonce to 2
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &lazy_nonce)
-    });
-
-    // Add consecutive payload hashes starting from lazy_nonce + 1
-    let payload_hash1 = BytesN::from_array(env, &[0xabu8; 32]);
-    let payload_hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
-    let payload_hash3 = BytesN::from_array(env, &[0xefu8; 32]);
-
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 3, &payload_hash1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 4, &payload_hash2)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 5, &payload_hash3)
-    });
 
-    // Inbound nonce should be 5 (lazy_nonce + 3 consecutive payload hashes)
-    let nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(nonce, 5);
+    context.set_lazy_inbound_nonce(&receiver, src_eid, &sender, 5);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 5);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 5);
 }
 
+// The inbound_nonce advances through the longest gapless consecutive sequence
 #[test]
-fn test_inbound_nonce_with_gap_in_payload_hashes() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+fn test_inbound_nonce_advances_through_consecutive_verified_payload_hashes() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
     let sender = BytesN::from_array(env, &[1u8; 32]);
-    let lazy_nonce = 2;
 
-    // Set lazy nonce to 2
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &lazy_nonce)
-    });
+    // Start from lazy_nonce = 2 and add payloads at 3,4,5.
+    context.set_lazy_inbound_nonce(&receiver, src_eid, &sender, 2);
+    inbound_as_verified_with_fixed_hash(&context, &receiver, src_eid, &sender, 3);
+    inbound_as_verified_with_fixed_hash(&context, &receiver, src_eid, &sender, 4);
+    inbound_as_verified_with_fixed_hash(&context, &receiver, src_eid, &sender, 5);
 
-    // Add payload hashes with a gap (nonce 3 and 5, but not 4)
-    let payload_hash1 = BytesN::from_array(env, &[0xabu8; 32]);
-    let payload_hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
-
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 3, &payload_hash1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 5, &payload_hash2)
-    });
-
-    // Inbound nonce should be 3 (stops at first gap)
-    let nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(nonce, 3);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 5);
 }
 
 #[test]
-fn test_inbound_nonce_with_zero_lazy_nonce_and_payload_hashes() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+fn test_inbound_nonce_stops_at_first_gap() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let receiver = Address::generate(env);
     let src_eid = 2;
     let sender = BytesN::from_array(env, &[1u8; 32]);
 
-    // Lazy nonce is 0 by default
-    // Add consecutive payload hashes starting from 1
-    let payload_hash1 = BytesN::from_array(env, &[0xabu8; 32]);
-    let payload_hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
-
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 1, &payload_hash1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 2, &payload_hash2)
-    });
+    // Start from lazy_nonce = 2 and add payloads at 3 and 5 (gap at 4).
+    context.set_lazy_inbound_nonce(&receiver, src_eid, &sender, 2);
+    inbound_as_verified_with_fixed_hash(&context, &receiver, src_eid, &sender, 3);
+    inbound_as_verified_with_fixed_hash(&context, &receiver, src_eid, &sender, 5);
 
-    // Inbound nonce should be 2 (0 + 2 consecutive payload hashes)
-    let nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(nonce, 2);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 3);
 }
 
+// Path isolation (receiver/src_eid/sender are isolated)
 #[test]
-fn test_inbound_nonce_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]);
-
-    // Set different lazy nonces for different paths
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid1, &sender1, &10)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver2, src_eid1, &sender1, &20)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid2, &sender1, &30)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver1, src_eid1, &sender2, &40)
-    });
-
-    // Add payload hashes for some paths
-    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
-
-    // Add payload hash for receiver1, src_eid1, sender1 (nonce 11)
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver1, src_eid1, &sender1, 11, &payload_hash)
-    });
-
-    // Add payload hash for receiver1, src_eid2, sender1 (nonce 31 and 32)
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver1, src_eid2, &sender1, 31, &payload_hash)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver1, src_eid2, &sender1, 32, &payload_hash)
-    });
-
-    // Verify each path has independent inbound nonce calculation
-    let nonce1 = endpoint_client.inbound_nonce(&receiver1, &src_eid1, &sender1);
-    let nonce2 = endpoint_client.inbound_nonce(&receiver2, &src_eid1, &sender1);
-    let nonce3 = endpoint_client.inbound_nonce(&receiver1, &src_eid2, &sender1);
-    let nonce4 = endpoint_client.inbound_nonce(&receiver1, &src_eid1, &sender2);
-
-    assert_eq!(nonce1, 11); // lazy_nonce 10 + 1 payload hash
-    assert_eq!(nonce2, 20); // lazy_nonce 20, no payload hashes
-    assert_eq!(nonce3, 32); // lazy_nonce 30 + 2 consecutive payload hashes
-    assert_eq!(nonce4, 40); // lazy_nonce 40, no payload hashes
-}
-
-#[test]
-fn test_inbound_nonce_large_consecutive_sequence() {
-    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 lazy_nonce = 100;
-    let sequence_length = 50;
-
-    // Set lazy nonce
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &lazy_nonce)
-    });
-
-    // Add a long sequence of consecutive payload hashes
-    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
-    for i in 1..=sequence_length {
-        env.as_contract(&endpoint_client.address, || {
-            EndpointV2::inbound(env, &receiver, src_eid, &sender, lazy_nonce + i, &payload_hash)
-        });
-    }
-
-    // Inbound nonce should be lazy_nonce + sequence_length
-    let nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(nonce, lazy_nonce + sequence_length);
-}
-
-#[test]
-fn test_inbound_nonce_after_payload_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 lazy_nonce = 5;
-
-    // Set lazy nonce
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &lazy_nonce)
-    });
-
-    // Add consecutive payload hashes
-    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 6, &payload_hash)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 7, &payload_hash)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 8, &payload_hash)
-    });
-
-    // Verify inbound nonce is 8
-    let nonce_before = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(nonce_before, 8);
-
-    // Remove payload hash at nonce 7 (creates a gap)
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::remove_inbound_payload_hash(env, &receiver, src_eid, &sender, 7)
-    });
-
-    // Inbound nonce should now be 6 (stops at the gap)
-    let nonce_after = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(nonce_after, 6);
-}
-
-#[test]
-fn test_inbound_nonce_no_payload_hash_at_lazy_nonce_plus_one() {
-    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 lazy_nonce = 10;
-
-    // Set lazy nonce
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &lazy_nonce)
-    });
-
-    // Add payload hash at nonce 12 (skipping nonce 11)
-    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]);
-    env.as_contract(&endpoint_client.address, || {
-        EndpointV2::inbound(env, &receiver, src_eid, &sender, 12, &payload_hash)
-    });
-
-    // Inbound nonce should remain at lazy_nonce (no consecutive sequence from lazy_nonce + 1)
-    let nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
-    assert_eq!(nonce, lazy_nonce);
+fn test_inbound_nonce_isolated_by_path() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver_a = Address::generate(env);
+    let receiver_b = Address::generate(env);
+    let src_eid_a = 2;
+    let src_eid_b = 3;
+    let sender_a = BytesN::from_array(env, &[1u8; 32]);
+    let sender_b = BytesN::from_array(env, &[2u8; 32]);
+
+    // Path A: lazy 10 + payload at 11 => inbound_nonce 11.
+    context.set_lazy_inbound_nonce(&receiver_a, src_eid_a, &sender_a, 10);
+    inbound_as_verified_with_fixed_hash(&context, &receiver_a, src_eid_a, &sender_a, 11);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver_a, &src_eid_a, &sender_a), 11);
+
+    // Path B: different receiver => independent.
+    context.set_lazy_inbound_nonce(&receiver_b, src_eid_a, &sender_a, 20);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver_b, &src_eid_a, &sender_a), 20);
+
+    // Path C: different src_eid => independent (two consecutive payloads).
+    context.set_lazy_inbound_nonce(&receiver_a, src_eid_b, &sender_a, 30);
+    inbound_as_verified_with_fixed_hash(&context, &receiver_a, src_eid_b, &sender_a, 31);
+    inbound_as_verified_with_fixed_hash(&context, &receiver_a, src_eid_b, &sender_a, 32);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver_a, &src_eid_b, &sender_a), 32);
+
+    // Path D: different sender => independent.
+    context.set_lazy_inbound_nonce(&receiver_a, src_eid_a, &sender_b, 40);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver_a, &src_eid_a, &sender_b), 40);
 }