@layerzerolabs/protocol-stellar-v2 0.2.8

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

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