@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,10 @@
+mod burn;
+mod clear;
+mod inbound_nonce;
+mod inbound_payload_hash;
+mod internal;
+mod lazy_inbound_nonce;
+mod next_guid;
+mod nilify;
+mod outbound_nonce;
+mod skip;

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

@@ -0,0 +1,239 @@
+use soroban_sdk::{testutils::Address as _, Address, BytesN};
+
+use crate::{storage, tests::endpoint_setup::setup, util};
+
+#[test]
+fn test_next_guid_basic() {
+    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]);
+
+    // Initially outbound nonce should be 0, so next_guid should use nonce 1
+    let initial_outbound_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(initial_outbound_nonce, 0);
+
+    // Get next GUID
+    let guid = endpoint_client.next_guid(&sender, &dst_eid, &receiver);
+
+    // Verify GUID is computed correctly using nonce 1
+    let expected_guid = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 1, test_setup.eid, &sender, dst_eid, &receiver)
+    });
+    assert_eq!(guid, expected_guid);
+
+    // Verify outbound nonce hasn't changed (next_guid is a view function)
+    let after_outbound_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(after_outbound_nonce, 0);
+}
+
+#[test]
+fn test_next_guid_with_existing_nonce() {
+    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]);
+
+    // Set outbound nonce to 5
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &5)
+    });
+
+    // Verify outbound nonce is 5
+    let current_outbound_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(current_outbound_nonce, 5);
+
+    // Get next GUID (should use nonce 6)
+    let guid = endpoint_client.next_guid(&sender, &dst_eid, &receiver);
+
+    // Verify GUID is computed correctly using nonce 6
+    let expected_guid = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 6, test_setup.eid, &sender, dst_eid, &receiver)
+    });
+    assert_eq!(guid, expected_guid);
+
+    // Verify outbound nonce hasn't changed
+    let after_outbound_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(after_outbound_nonce, 5);
+}
+
+#[test]
+fn test_next_guid_different_senders() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender1 = Address::generate(env);
+    let sender2 = Address::generate(env);
+    let dst_eid = 2;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+
+    // Get GUIDs for different senders
+    let guid1 = endpoint_client.next_guid(&sender1, &dst_eid, &receiver);
+    let guid2 = endpoint_client.next_guid(&sender2, &dst_eid, &receiver);
+
+    // Verify GUIDs are different (different senders should produce different GUIDs)
+    assert_ne!(guid1, guid2);
+
+    // Verify both use nonce 1 (independent nonce counters)
+    let expected_guid1 = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 1, test_setup.eid, &sender1, dst_eid, &receiver)
+    });
+    let expected_guid2 = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 1, test_setup.eid, &sender2, dst_eid, &receiver)
+    });
+
+    assert_eq!(guid1, expected_guid1);
+    assert_eq!(guid2, expected_guid2);
+}
+
+#[test]
+fn test_next_guid_different_dst_eids() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid1 = 2;
+    let dst_eid2 = 3;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+
+    // Get GUIDs for different destination EIDs
+    let guid1 = endpoint_client.next_guid(&sender, &dst_eid1, &receiver);
+    let guid2 = endpoint_client.next_guid(&sender, &dst_eid2, &receiver);
+
+    // Verify GUIDs are different (different dst_eids should produce different GUIDs)
+    assert_ne!(guid1, guid2);
+
+    // Verify both use nonce 1 (independent nonce counters per dst_eid)
+    let expected_guid1 = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 1, test_setup.eid, &sender, dst_eid1, &receiver)
+    });
+    let expected_guid2 = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 1, test_setup.eid, &sender, dst_eid2, &receiver)
+    });
+
+    assert_eq!(guid1, expected_guid1);
+    assert_eq!(guid2, expected_guid2);
+}
+
+#[test]
+fn test_next_guid_different_receivers() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2;
+    let receiver1 = BytesN::from_array(env, &[1u8; 32]);
+    let receiver2 = BytesN::from_array(env, &[2u8; 32]);
+
+    // Get GUIDs for different receivers
+    let guid1 = endpoint_client.next_guid(&sender, &dst_eid, &receiver1);
+    let guid2 = endpoint_client.next_guid(&sender, &dst_eid, &receiver2);
+
+    // Verify GUIDs are different (different receivers should produce different GUIDs)
+    assert_ne!(guid1, guid2);
+
+    // Verify both use nonce 1 (independent nonce counters per receiver)
+    let expected_guid1 = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 1, test_setup.eid, &sender, dst_eid, &receiver1)
+    });
+    let expected_guid2 = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 1, test_setup.eid, &sender, dst_eid, &receiver2)
+    });
+
+    assert_eq!(guid1, expected_guid1);
+    assert_eq!(guid2, expected_guid2);
+}
+
+#[test]
+fn test_next_guid_sequential_calls() {
+    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]);
+
+    // Multiple calls to next_guid should return the same GUID (view function)
+    let guid1 = endpoint_client.next_guid(&sender, &dst_eid, &receiver);
+    let guid2 = endpoint_client.next_guid(&sender, &dst_eid, &receiver);
+    let guid3 = endpoint_client.next_guid(&sender, &dst_eid, &receiver);
+
+    // All GUIDs should be the same since outbound nonce hasn't changed
+    assert_eq!(guid1, guid2);
+    assert_eq!(guid2, guid3);
+
+    // All should use nonce 1
+    let expected_guid = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 1, test_setup.eid, &sender, dst_eid, &receiver)
+    });
+    assert_eq!(guid1, expected_guid);
+}
+
+#[test]
+fn test_next_guid_after_outbound_increment() {
+    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]);
+
+    // Get initial GUID (should use nonce 1)
+    let guid1 = endpoint_client.next_guid(&sender, &dst_eid, &receiver);
+    let expected_guid1 = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 1, test_setup.eid, &sender, dst_eid, &receiver)
+    });
+    assert_eq!(guid1, expected_guid1);
+
+    // Simulate incrementing outbound nonce (as would happen in actual send)
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &1)
+    });
+
+    // Get next GUID (should now use nonce 2)
+    let guid2 = endpoint_client.next_guid(&sender, &dst_eid, &receiver);
+    let expected_guid2 = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, 2, test_setup.eid, &sender, dst_eid, &receiver)
+    });
+    assert_eq!(guid2, expected_guid2);
+
+    // Verify GUIDs are different
+    assert_ne!(guid1, guid2);
+}
+
+#[test]
+fn test_next_guid_large_nonce() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let large_nonce = u64::MAX - 1;
+
+    // Set outbound nonce to a large value
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &large_nonce)
+    });
+
+    // Get next GUID (should use nonce u64::MAX)
+    let guid = endpoint_client.next_guid(&sender, &dst_eid, &receiver);
+
+    // Verify GUID is computed correctly with large nonce
+    let expected_guid = env.as_contract(&endpoint_client.address, || {
+        util::compute_guid(env, u64::MAX, test_setup.eid, &sender, dst_eid, &receiver)
+    });
+    assert_eq!(guid, expected_guid);
+}

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

@@ -0,0 +1,324 @@
+use soroban_sdk::{testutils::Address as _, Address, BytesN, IntoVal};
+
+use crate::{endpoint_v2::EndpointV2, events::PacketNilified, storage, tests::endpoint_setup::setup};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_nilify_success_with_stored_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_hash = BytesN::from_array(env, &[0xabu8; 32]);
+
+    // Store a payload hash first
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+    });
+
+    // Verify payload hash is 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()));
+
+    // Nilify the payload
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "nilify",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce, &Some(payload_hash.clone())).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .nilify(&receiver, &receiver, &src_eid, &sender, &nonce, &Some(payload_hash.clone()));
+
+    // Verify PacketNilified event was emitted
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketNilified {
+            src_eid,
+            sender: sender.clone(),
+            receiver: receiver.clone(),
+            nonce,
+            payload_hash: Some(payload_hash.clone()),
+        },
+    );
+
+    // Verify payload hash was replaced with nil hash
+    let nilified_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    let expected_nil_hash = env.as_contract(&endpoint_client.address, || EndpointV2::nil_payload_hash(env));
+    assert_eq!(nilified_hash, Some(expected_nil_hash));
+}
+
+#[test]
+fn test_nilify_success_with_empty_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 = 2;
+
+    // Set lazy nonce to 1 so nonce 2 is greater than lazy nonce
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_lazy_inbound_nonce(env, &receiver, src_eid, &sender, &1)
+    });
+
+    // Nilify with None
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "nilify",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce, &None::<BytesN<32>>).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .nilify(&receiver, &receiver, &src_eid, &sender, &nonce, &None);
+
+    // Verify PacketNilified event was emitted
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketNilified { src_eid, sender: sender.clone(), receiver: receiver.clone(), nonce, payload_hash: None },
+    );
+
+    // Verify payload hash was set to nil hash
+    let nilified_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    let expected_nil_hash = env.as_contract(&endpoint_client.address, || EndpointV2::nil_payload_hash(env));
+    assert_eq!(nilified_hash, Some(expected_nil_hash));
+}
+
+#[test]
+fn test_nilify_with_delegate() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let delegate = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1;
+    let payload_hash = BytesN::from_array(env, &[0xcdu8; 32]);
+
+    // Set delegate for receiver
+    env.as_contract(&endpoint_client.address, || storage::EndpointStorage::set_delegate(env, &receiver, &delegate));
+
+    // Store a payload hash first
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce, &payload_hash)
+    });
+
+    // Delegate can nilify on behalf of receiver
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &delegate,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "nilify",
+                args: (&delegate, &receiver, &src_eid, &sender, &nonce, &Some(payload_hash.clone())).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .nilify(&delegate, &receiver, &src_eid, &sender, &nonce, &Some(payload_hash.clone()));
+
+    // Verify PacketNilified event was emitted
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketNilified {
+            src_eid,
+            sender: sender.clone(),
+            receiver: receiver.clone(),
+            nonce,
+            payload_hash: Some(payload_hash.clone()),
+        },
+    );
+
+    // Verify payload hash was replaced with nil hash
+    let nilified_hash = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    let expected_nil_hash = env.as_contract(&endpoint_client.address, || EndpointV2::nil_payload_hash(env));
+    assert_eq!(nilified_hash, Some(expected_nil_hash));
+}
+
+#[test]
+fn test_nilify_multiple_payloads() {
+    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 payload_hash1 = BytesN::from_array(env, &[0xabu8; 32]);
+    let payload_hash2 = BytesN::from_array(env, &[0xcdu8; 32]);
+    let nonce1 = 1;
+    let nonce2 = 2;
+
+    // Store multiple payload hashes
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce1, &payload_hash1)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver, src_eid, &sender, nonce2, &payload_hash2)
+    });
+
+    // Nilify first payload
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "nilify",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce1, &Some(payload_hash1.clone())).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .nilify(&receiver, &receiver, &src_eid, &sender, &nonce1, &Some(payload_hash1.clone()));
+
+    // Nilify second payload
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "nilify",
+                args: (&receiver, &receiver, &src_eid, &sender, &nonce2, &Some(payload_hash2.clone())).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .nilify(&receiver, &receiver, &src_eid, &sender, &nonce2, &Some(payload_hash2.clone()));
+
+    // Verify both payload hashes were replaced with nil hash
+    let expected_nil_hash = env.as_contract(&endpoint_client.address, || EndpointV2::nil_payload_hash(env));
+
+    let nilified_hash1 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce1)
+    });
+    let nilified_hash2 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce2)
+    });
+
+    assert_eq!(nilified_hash1, Some(expected_nil_hash.clone()));
+    assert_eq!(nilified_hash2, Some(expected_nil_hash));
+}
+
+#[test]
+fn test_nilify_different_paths() {
+    let test_setup = setup();
+    let env = &test_setup.env;
+    let endpoint_client = &test_setup.endpoint_client;
+
+    let receiver1 = Address::generate(env);
+    let receiver2 = Address::generate(env);
+    let src_eid1 = 2;
+    let src_eid2 = 3;
+    let sender1 = BytesN::from_array(env, &[1u8; 32]);
+    let sender2 = BytesN::from_array(env, &[2u8; 32]);
+    let nonce = 1;
+    let payload_hash = BytesN::from_array(env, &[0xefu8; 32]);
+
+    // Store payload hashes for different paths
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver1, src_eid1, &sender1, nonce, &payload_hash)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver2, src_eid1, &sender1, nonce, &payload_hash)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver1, src_eid2, &sender1, nonce, &payload_hash)
+    });
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::inbound(env, &receiver1, src_eid1, &sender2, nonce, &payload_hash)
+    });
+
+    // Nilify for different receivers
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver1,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "nilify",
+                args: (&receiver1, &receiver1, &src_eid1, &sender1, &nonce, &Some(payload_hash.clone())).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .nilify(&receiver1, &receiver1, &src_eid1, &sender1, &nonce, &Some(payload_hash.clone()));
+
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver2,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "nilify",
+                args: (&receiver2, &receiver2, &src_eid1, &sender1, &nonce, &Some(payload_hash.clone())).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .nilify(&receiver2, &receiver2, &src_eid1, &sender1, &nonce, &Some(payload_hash.clone()));
+
+    // Nilify for different src_eids
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver1,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "nilify",
+                args: (&receiver1, &receiver1, &src_eid2, &sender1, &nonce, &Some(payload_hash.clone())).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .nilify(&receiver1, &receiver1, &src_eid2, &sender1, &nonce, &Some(payload_hash.clone()));
+
+    // Nilify for different senders
+    endpoint_client
+        .mock_auths(&[soroban_sdk::testutils::MockAuth {
+            address: &receiver1,
+            invoke: &soroban_sdk::testutils::MockAuthInvoke {
+                contract: &endpoint_client.address,
+                fn_name: "nilify",
+                args: (&receiver1, &receiver1, &src_eid1, &sender2, &nonce, &Some(payload_hash.clone())).into_val(env),
+                sub_invokes: &[],
+            },
+        }])
+        .nilify(&receiver1, &receiver1, &src_eid1, &sender2, &nonce, &Some(payload_hash.clone()));
+
+    // Verify all paths have been nilified independently
+    let expected_nil_hash = env.as_contract(&endpoint_client.address, || EndpointV2::nil_payload_hash(env));
+
+    let nilified_hash1 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver1, src_eid1, &sender1, nonce)
+    });
+    let nilified_hash2 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver2, src_eid1, &sender1, nonce)
+    });
+    let nilified_hash3 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver1, src_eid2, &sender1, nonce)
+    });
+    let nilified_hash4 = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver1, src_eid1, &sender2, nonce)
+    });
+
+    assert_eq!(nilified_hash1, Some(expected_nil_hash.clone()));
+    assert_eq!(nilified_hash2, Some(expected_nil_hash.clone()));
+    assert_eq!(nilified_hash3, Some(expected_nil_hash.clone()));
+    assert_eq!(nilified_hash4, Some(expected_nil_hash));
+}