@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,316 @@
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, IntoVal};
+
+use crate::{
+    endpoint_v2::EndpointV2,
+    errors::EndpointError,
+    events::PacketDelivered,
+    interfaces::Origin,
+    storage,
+    tests::endpoint_setup::setup,
+    util::{build_payload, compute_guid},
+};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_clear_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_bytes = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let message = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+
+    // Compute guid and build payload
+    let guid =
+        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
+    let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &guid, &message));
+
+    // Compute and store payload hash
+    let payload_hash = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
+    });
+
+    // Verify payload hash is stored
+    let stored = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender_bytes, nonce)
+    });
+    assert_eq!(stored, Some(payload_hash.clone()));
+
+    // Clear the payload (receiver authorizes itself)
+    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "clear",
+                args: (&receiver, &origin, &receiver, &guid, &message).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .clear(&receiver, &origin, &receiver, &guid, &message);
+
+    // Verify PacketDelivered event was emitted
+    assert_event(env, &endpoint_client.address, PacketDelivered { origin: origin.clone(), receiver: receiver.clone() });
+
+    // Verify payload hash is removed
+    let cleared = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender_bytes, nonce)
+    });
+    assert_eq!(cleared, None);
+
+    // Verify lazy nonce was updated
+    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender_bytes)
+    });
+    assert_eq!(lazy_nonce, nonce);
+}
+
+#[test]
+fn test_clear_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_bytes = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let message = Bytes::from_array(env, &[0xdd, 0xee, 0xff]);
+
+    // Set delegate for receiver
+    env.as_contract(&endpoint_client.address, || storage::EndpointStorage::set_delegate(env, &receiver, &delegate));
+
+    // Compute guid and build payload
+    let guid =
+        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
+    let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &guid, &message));
+
+    // Store payload hash
+    let payload_hash = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
+    });
+
+    // Clear using delegate
+    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &delegate,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "clear",
+                args: (&delegate, &origin, &receiver, &guid, &message).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .clear(&delegate, &origin, &receiver, &guid, &message);
+
+    // Verify PacketDelivered event was emitted
+    assert_event(env, &endpoint_client.address, PacketDelivered { origin: origin.clone(), receiver: receiver.clone() });
+
+    // Verify payload is cleared
+    let cleared = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender_bytes, nonce)
+    });
+    assert_eq!(cleared, None);
+}
+
+#[test]
+fn test_panic_clear_unauthorized() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let unauthorized_caller = Address::generate(env);
+    let src_eid = 2;
+    let sender_bytes = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let message = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+
+    let guid =
+        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
+
+    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
+
+    // Try to clear with unauthorized caller - should panic
+    assert_eq!(
+        endpoint_client
+            .mock_auths(&[soroban_sdk::testutils::MockAuth {
+                address: &unauthorized_caller,
+                invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                    contract: &endpoint_client.address,
+                    fn_name: "clear",
+                    args: (&unauthorized_caller, &origin, &receiver, &guid, &message).into_val(env),
+                    sub_invokes: &[],
+                },
+            }])
+            .try_clear(&unauthorized_caller, &origin, &receiver, &guid, &message)
+            .unwrap_err()
+            .unwrap(),
+        EndpointError::Unauthorized.into()
+    );
+}
+
+#[test]
+fn test_panic_clear_wrong_message() {
+    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_bytes = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let correct_message = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+    let wrong_message = Bytes::from_array(env, &[0xdd, 0xee, 0xff]);
+
+    // Store with correct message
+    let guid =
+        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
+    let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &guid, &correct_message));
+    let payload_hash = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
+    });
+
+    // Try to clear with wrong message - should panic
+    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
+    assert_eq!(
+        endpoint_client
+            .mock_auths(&[soroban_sdk::testutils::MockAuth {
+                address: &receiver,
+                invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                    contract: &endpoint_client.address,
+                    fn_name: "clear",
+                    args: (&receiver, &origin, &receiver, &guid, &wrong_message).into_val(env),
+                    sub_invokes: &[],
+                },
+            }])
+            .try_clear(&receiver, &origin, &receiver, &guid, &wrong_message)
+            .unwrap_err()
+            .unwrap(),
+        EndpointError::PayloadHashNotFound.into()
+    );
+}
+
+#[test]
+fn test_panic_clear_wrong_guid() {
+    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_bytes = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let message = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+
+    // Store with correct guid
+    let correct_guid =
+        env.as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
+    let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &correct_guid, &message));
+    let payload_hash = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
+    });
+
+    // Try to clear with wrong guid - should panic
+    let wrong_guid = BytesN::from_array(env, &[0xffu8; 32]);
+    let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
+    assert_eq!(
+        endpoint_client
+            .mock_auths(&[soroban_sdk::testutils::MockAuth {
+                address: &receiver,
+                invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                    contract: &endpoint_client.address,
+                    fn_name: "clear",
+                    args: (&receiver, &origin, &receiver, &wrong_guid, &message).into_val(env),
+                    sub_invokes: &[],
+                },
+            }])
+            .try_clear(&receiver, &origin, &receiver, &wrong_guid, &message)
+            .unwrap_err()
+            .unwrap(),
+        EndpointError::PayloadHashNotFound.into()
+    );
+}
+
+#[test]
+fn test_clear_multiple_sequential() {
+    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_bytes = BytesN::from_array(env, &[1u8; 32]);
+
+    // Store 3 payloads
+    for nonce in 1..=3 {
+        let message = Bytes::from_array(env, &[nonce as u8]);
+        let guid = env
+            .as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
+        let payload = env.as_contract(&endpoint_client.address, || build_payload(env, &guid, &message));
+        let payload_hash = env.as_contract(&endpoint_client.address, || {
+            BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
+        });
+        env.as_contract(&endpoint_client.address, || {
+            EndpointV2::inbound(env, &receiver, src_eid, &sender_bytes, nonce, &payload_hash)
+        });
+    }
+
+    // Clear them in order
+    for nonce in 1..=3 {
+        let message = Bytes::from_array(env, &[nonce as u8]);
+        let guid = env
+            .as_contract(&endpoint_client.address, || compute_guid(env, nonce, src_eid, &receiver, 1, &sender_bytes));
+        let origin = Origin { src_eid, sender: sender_bytes.clone(), nonce };
+
+        endpoint_client
+            .mock_auths(&[soroban_sdk::testutils::MockAuth {
+                address: &receiver,
+                invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                    contract: &endpoint_client.address,
+                    fn_name: "clear",
+                    args: (&receiver, &origin, &receiver, &guid, &message).into_val(env),
+                    sub_invokes: &[],
+                },
+            }])
+            .clear(&receiver, &origin, &receiver, &guid, &message);
+    }
+
+    // Verify all are cleared
+    for nonce in 1..=3 {
+        let cleared = env.as_contract(&endpoint_client.address, || {
+            storage::EndpointStorage::inbound_payload_hash(
+                env,
+                &receiver,
+                src_eid,
+                &sender_bytes,
+                nonce,
+            )
+        });
+        assert_eq!(cleared, None);
+    }
+
+    // Verify lazy nonce is updated to 3
+    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender_bytes)
+    });
+    assert_eq!(lazy_nonce, 3);
+}

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

@@ -0,0 +1,288 @@
+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);
+}
+
+#[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;
+
+    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);
+}
+
+#[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;
+
+    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);
+}
+
+#[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;
+
+    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 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);
+}
+
+#[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;
+
+    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)
+    });
+
+    // Inbound nonce should be 2 (0 + 2 consecutive payload hashes)
+    let nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(nonce, 2);
+}
+
+#[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);
+}