@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,388 @@
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
+
+use crate::{endpoint_v2::EndpointV2, storage, tests::endpoint_setup::setup};
+
+// ============================================================================
+// Tests for outbound function
+// ============================================================================
+
+#[test]
+fn test_outbound() {
+    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]);
+
+    // First call should return nonce 1
+    let nonce1 = env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
+    assert_eq!(nonce1, 1);
+
+    // Second call should return nonce 2
+    let nonce2 = env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
+    assert_eq!(nonce2, 2);
+
+    // Third call should return nonce 3
+    let nonce3 = env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
+    assert_eq!(nonce3, 3);
+
+    // Different sender should have independent nonce counter (starts at 1)
+    let different_sender = Address::generate(env);
+    let nonce_diff_sender =
+        env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &different_sender, dst_eid, &receiver));
+    assert_eq!(nonce_diff_sender, 1);
+
+    // Different dst_eid should have independent nonce counter (starts at 1)
+    let different_dst_eid = 3;
+    let nonce_diff_dst =
+        env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, different_dst_eid, &receiver));
+    assert_eq!(nonce_diff_dst, 1);
+
+    // Different receiver should have independent nonce counter (starts at 1)
+    let different_receiver = BytesN::from_array(env, &[2u8; 32]);
+    let nonce_diff_receiver =
+        env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &different_receiver));
+    assert_eq!(nonce_diff_receiver, 1);
+
+    // Verify storage was updated correctly for original path
+    let stored_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::outbound_nonce(env, &sender, dst_eid, &receiver)
+    });
+    assert_eq!(stored_nonce, 3);
+}
+
+// ============================================================================
+// Tests for inbound function
+// ============================================================================
+
+#[test]
+fn test_inbound_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;
+    let payload_hash = BytesN::from_array(env, &[0xabu8; 32]); // Valid non-empty payload hash
+
+    // Call inbound with non-empty payload hash - should succeed
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+    });
+
+    // Verify storage was updated correctly
+    let stored_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(stored_hash, Some(payload_hash.clone()));
+
+    // Test with different nonce for same path
+    let nonce2 = 2;
+    let payload_hash2 = BytesN::from_array(env, &[0xcdu8; 32]); // Different payload hash
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce2, &payload_hash2)
+    });
+
+    let stored_hash2 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce2)
+    });
+    assert_eq!(stored_hash2, Some(payload_hash2.clone()));
+
+    // Test with 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)
+    });
+
+    let stored_hash_diff = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(
+            env,
+            &different_receiver,
+            src_eid,
+            &sender,
+            nonce,
+        )
+    });
+    assert_eq!(stored_hash_diff, Some(payload_hash3.clone()));
+
+    // Original receiver's storage should be unchanged
+    let original_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(original_hash, Some(payload_hash));
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #11)")] // EndpointError::InvalidPayloadHash
+fn test_inbound_empty_payload_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 empty_hash = BytesN::from_array(env, &[0u8; 32]); // empty_payload_hash - now invalid
+
+    // Should panic with InvalidPayloadHash error because empty hash is not allowed
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &empty_hash)
+    });
+}
+
+// ============================================================================
+// Tests for clear_payload function
+// ============================================================================
+
+#[test]
+fn test_clear_payload_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;
+    let payload = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+
+    // Compute the expected hash
+    let payload_hash = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
+    });
+
+    // First store the payload hash via inbound
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+    });
+
+    // Verify it's stored
+    let stored_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(stored_hash, Some(payload_hash.clone()));
+
+    // Clear the payload
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, nonce, &payload)
+    });
+
+    // Verify it's removed from storage
+    let cleared_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(cleared_hash, 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)
+    });
+    assert_eq!(lazy_nonce, nonce);
+}
+
+#[test]
+fn test_clear_payload_with_lazy_nonce_update() {
+    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]);
+
+    // Store three payloads (nonce 1, 2, 3)
+    let payload1 = Bytes::from_array(env, &[0x01]);
+    let payload2 = Bytes::from_array(env, &[0x02]);
+    let payload3 = Bytes::from_array(env, &[0x03]);
+
+    let hash1 = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload1).to_array())
+    });
+    let hash2 = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload2).to_array())
+    });
+    let hash3 = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload3).to_array())
+    });
+
+    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, 2, &hash2));
+    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 3, &hash3));
+
+    // Lazy nonce should be 0 (not updated yet)
+    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
+    });
+    assert_eq!(lazy_nonce, 0);
+
+    // Clear payload 3 directly (skipping 1 and 2)
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 3, &payload3)
+    });
+
+    // Lazy nonce should be updated to 3
+    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
+    });
+    assert_eq!(lazy_nonce, 3);
+
+    // Payload 3 should be cleared
+    let hash3_after = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, 3)
+    });
+    assert_eq!(hash3_after, None);
+}
+
+#[test]
+fn test_clear_payload_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 = BytesN::from_array(env, &[1u8; 32]);
+
+    // Store three payloads
+    let payload1 = Bytes::from_array(env, &[0x01]);
+    let payload2 = Bytes::from_array(env, &[0x02]);
+    let payload3 = Bytes::from_array(env, &[0x03]);
+
+    let hash1 = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload1).to_array())
+    });
+    let hash2 = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload2).to_array())
+    });
+    let hash3 = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload3).to_array())
+    });
+
+    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, 2, &hash2));
+    env.as_contract(&endpoint_client.address, || EndpointV2::inbound(env, &receiver, src_eid, &sender, 3, &hash3));
+
+    // Clear them in order: 1, 2, 3
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 1, &payload1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 2, &payload2)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 3, &payload3)
+    });
+
+    // All should be cleared
+    let hash1_after = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, 1)
+    });
+    let hash2_after = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, 2)
+    });
+    let hash3_after = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, 3)
+    });
+
+    assert_eq!(hash1_after, None);
+    assert_eq!(hash2_after, None);
+    assert_eq!(hash3_after, None);
+
+    // Lazy nonce should be 3
+    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
+    });
+    assert_eq!(lazy_nonce, 3);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #19)")] // EndpointError::PayloadHashNotFound
+fn test_clear_payload_wrong_payload() {
+    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 = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+    let wrong_payload = Bytes::from_array(env, &[0xdd, 0xee, 0xff]); // Different payload
+
+    let payload_hash = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload).to_array())
+    });
+
+    // Store the correct hash
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+    });
+
+    // Try to clear with wrong payload - should panic
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, nonce, &wrong_payload)
+    });
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #10)")] // EndpointError::InvalidNonce
+fn test_clear_payload_not_stored() {
+    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 = Bytes::from_array(env, &[0xaa, 0xbb, 0xcc]);
+
+    // Try to clear without storing first - should panic with InvalidNonce
+    // (because intermediate nonce validation fails before checking payload hash)
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, nonce, &payload)
+    });
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #10)")] // EndpointError::InvalidNonce
+fn test_clear_payload_missing_intermediate_nonce() {
+    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]);
+
+    // Store only nonce 1 and 3, skip nonce 2
+    let payload1 = Bytes::from_array(env, &[0x01]);
+    let payload3 = Bytes::from_array(env, &[0x03]);
+
+    let hash1 = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload1).to_array())
+    });
+    let hash3 = env.as_contract(&endpoint_client.address, || {
+        BytesN::from_array(env, &env.crypto().keccak256(&payload3).to_array())
+    });
+
+    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, 3, &hash3));
+
+    // Clear nonce 1 first
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 1, &payload1)
+    });
+
+    // Try to clear nonce 3 - should panic because nonce 2 is missing
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::clear_payload(env, &receiver, src_eid, &sender, 3, &payload3)
+    });
+}

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

@@ -0,0 +1,307 @@
+use soroban_sdk::{testutils::Address as _, Address, BytesN};
+
+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 receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Initial lazy inbound nonce should be 0
+    let nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(nonce, 0);
+}
+
+#[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 receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let expected_nonce = 42;
+
+    // Set lazy inbound nonce
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &expected_nonce)
+    });
+
+    // Verify lazy inbound nonce is retrieved correctly
+    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);
+}