@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -0,0 +1,68 @@
+use soroban_sdk::{testutils::Address as _, Address, BytesN};
+
+use crate::{endpoint_v2::EndpointV2, storage, tests::endpoint_setup::setup};
+
+// Internal outbound() increments outbound nonce per path
+#[test]
+fn test_outbound_increments_and_is_path_scoped() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.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 state was updated correctly for original path.
+    assert_eq!(endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver), 3);
+}
+
+// Outbound() panics on overflow (debug build behavior)
+#[test]
+#[should_panic(expected = "attempt to add with overflow")]
+fn test_outbound_panics_on_u64_overflow() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+
+    // Force the stored outbound nonce to u64::MAX, so (nonce + 1) overflows.
+    env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &u64::MAX)
+    });
+
+    env.as_contract(&endpoint_client.address, || EndpointV2::outbound(env, &sender, dst_eid, &receiver));
+}

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

@@ -4,9 +4,9 @@ use crate::{storage, tests::endpoint_setup::setup};
 
 #[test]
 fn test_outbound_nonce_initial_value() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let sender = Address::generate(env);
     let dst_eid = 2;
@@ -19,9 +19,9 @@ fn test_outbound_nonce_initial_value() {
 
 #[test]
 fn test_outbound_nonce_after_setting() {
-    let test_setup = setup();
-    let env = &test_setup.env;
-    let endpoint_client = &test_setup.endpoint_client;
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
 
     let sender = Address::generate(env);
     let dst_eid = 2;
@@ -37,206 +37,3 @@ fn test_outbound_nonce_after_setting() {
     let nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
     assert_eq!(nonce, expected_nonce);
 }
-
-#[test]
-fn test_outbound_nonce_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]);
-
-    // Set different nonces for different senders
-    let nonce1 = 10;
-    let nonce2 = 20;
-
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender1, dst_eid, &receiver, &nonce1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender2, dst_eid, &receiver, &nonce2)
-    });
-
-    // Verify each sender has its own independent nonce
-    let retrieved_nonce1 = endpoint_client.outbound_nonce(&sender1, &dst_eid, &receiver);
-    let retrieved_nonce2 = endpoint_client.outbound_nonce(&sender2, &dst_eid, &receiver);
-
-    assert_eq!(retrieved_nonce1, nonce1);
-    assert_eq!(retrieved_nonce2, nonce2);
-
-    // Verify a third sender still has initial nonce of 0
-    let sender3 = Address::generate(env);
-    let retrieved_nonce3 = endpoint_client.outbound_nonce(&sender3, &dst_eid, &receiver);
-    assert_eq!(retrieved_nonce3, 0);
-}
-
-#[test]
-fn test_outbound_nonce_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]);
-
-    // Set different nonces for different destination EIDs
-    let nonce1 = 15;
-    let nonce2 = 25;
-
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid1, &receiver, &nonce1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid2, &receiver, &nonce2)
-    });
-
-    // Verify each dst_eid has its own independent nonce
-    let retrieved_nonce1 = endpoint_client.outbound_nonce(&sender, &dst_eid1, &receiver);
-    let retrieved_nonce2 = endpoint_client.outbound_nonce(&sender, &dst_eid2, &receiver);
-
-    assert_eq!(retrieved_nonce1, nonce1);
-    assert_eq!(retrieved_nonce2, nonce2);
-
-    // Verify a third dst_eid still has initial nonce of 0
-    let dst_eid3 = 4;
-    let retrieved_nonce3 = endpoint_client.outbound_nonce(&sender, &dst_eid3, &receiver);
-    assert_eq!(retrieved_nonce3, 0);
-}
-
-#[test]
-fn test_outbound_nonce_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]);
-
-    // Set different nonces for different receivers
-    let nonce1 = 30;
-    let nonce2 = 40;
-
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver1, &nonce1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver2, &nonce2)
-    });
-
-    // Verify each receiver has its own independent nonce
-    let retrieved_nonce1 = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver1);
-    let retrieved_nonce2 = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver2);
-
-    assert_eq!(retrieved_nonce1, nonce1);
-    assert_eq!(retrieved_nonce2, nonce2);
-
-    // Verify a third receiver still has initial nonce of 0
-    let receiver3 = BytesN::from_array(env, &[3u8; 32]);
-    let retrieved_nonce3 = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver3);
-    assert_eq!(retrieved_nonce3, 0);
-}
-
-#[test]
-fn test_outbound_nonce_large_values() {
-    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]);
-
-    // Test with maximum u64 value
-    let max_nonce = u64::MAX;
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &max_nonce)
-    });
-
-    let retrieved_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
-    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_outbound_nonce(env, &sender, dst_eid, &receiver, &large_nonce)
-    });
-
-    let retrieved_large_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
-    assert_eq!(retrieved_large_nonce, large_nonce);
-}
-
-#[test]
-fn test_outbound_nonce_incremental_updates() {
-    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]);
-
-    // Start with nonce 0
-    let initial_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
-    assert_eq!(initial_nonce, 0);
-
-    // Incrementally update nonce
-    for expected_nonce in 1..=10 {
-        env.as_contract(&endpoint_client.address, || {
-            storage::EndpointStorage::set_outbound_nonce(env, &sender, dst_eid, &receiver, &expected_nonce)
-        });
-
-        let retrieved_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
-        assert_eq!(retrieved_nonce, expected_nonce);
-    }
-}
-
-#[test]
-fn test_outbound_nonce_multiple_paths_independence() {
-    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_eid1 = 2;
-    let dst_eid2 = 3;
-    let receiver1 = BytesN::from_array(env, &[1u8; 32]);
-    let receiver2 = BytesN::from_array(env, &[2u8; 32]);
-
-    // Set nonces for different combinations
-    let nonce_s1_e1_r1 = 100;
-    let nonce_s1_e1_r2 = 200;
-    let nonce_s1_e2_r1 = 300;
-    let nonce_s2_e1_r1 = 400;
-
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender1, dst_eid1, &receiver1, &nonce_s1_e1_r1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender1, dst_eid1, &receiver2, &nonce_s1_e1_r2)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender1, dst_eid2, &receiver1, &nonce_s1_e2_r1)
-    });
-    env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::set_outbound_nonce(env, &sender2, dst_eid1, &receiver1, &nonce_s2_e1_r1)
-    });
-
-    // Verify all paths are independent
-    assert_eq!(endpoint_client.outbound_nonce(&sender1, &dst_eid1, &receiver1), nonce_s1_e1_r1);
-    assert_eq!(endpoint_client.outbound_nonce(&sender1, &dst_eid1, &receiver2), nonce_s1_e1_r2);
-    assert_eq!(endpoint_client.outbound_nonce(&sender1, &dst_eid2, &receiver1), nonce_s1_e2_r1);
-    assert_eq!(endpoint_client.outbound_nonce(&sender2, &dst_eid1, &receiver1), nonce_s2_e1_r1);
-
-    // Verify unset paths still return 0
-    assert_eq!(endpoint_client.outbound_nonce(&sender2, &dst_eid1, &receiver2), 0);
-    assert_eq!(endpoint_client.outbound_nonce(&sender2, &dst_eid2, &receiver1), 0);
-    assert_eq!(endpoint_client.outbound_nonce(&sender2, &dst_eid2, &receiver2), 0);
-}