@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,114 +1,131 @@
-use soroban_sdk::{testutils::Address as _, Address, BytesN, IntoVal};
-
-use crate::{events::InboundNonceSkipped, storage, tests::endpoint_setup::setup};
+use soroban_sdk::{testutils::Address as _, Address, BytesN};
 use utils::testing_utils::assert_event;
 
+use crate::{
+    errors::EndpointError, events::InboundNonceSkipped, storage, tests::endpoint_setup::setup,
+    tests::endpoint_setup::TestSetup,
+};
+
+fn skip_with_auth(
+    context: &TestSetup,
+    caller: &Address,
+    receiver: &Address,
+    src_eid: u32,
+    sender: &BytesN<32>,
+    nonce: u64,
+) {
+    context.mock_auth(caller, "skip", (caller, receiver, &src_eid, sender, &nonce));
+    context.endpoint_client.skip(caller, receiver, &src_eid, sender, &nonce);
+}
+
+// Authorization (receiver or delegate(receiver) must authorize)
+#[test]
+fn test_skip_unauthorized() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let unauthorized = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1u64;
+
+    // Unauthorized should fail before require_auth, so no mock_auth is needed.
+    let result = endpoint_client.try_skip(&unauthorized, &receiver, &src_eid, &sender, &nonce);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::Unauthorized.into());
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_skip_requires_auth_even_when_caller_is_receiver() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1u64;
+
+    // No mock_auth here: require_oapp_auth passes the (caller == receiver) check,
+    // then panics at caller.require_auth().
+    endpoint_client.skip(&receiver, &receiver, &src_eid, &sender, &nonce);
+}
+
+// Successful skip updates inbound/lazy nonces and emits InboundNonceSkipped
 #[test]
 fn test_skip_success() {
-    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 receiver = Address::generate(env);
     let src_eid = 2;
     let sender = BytesN::from_array(env, &[1u8; 32]);
     let nonce = 1;
 
-    // Verify initial state - lazy inbound nonce should be 0
-    let initial_lazy_nonce = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
-    });
+    // Verify initial state: lazy inbound nonce should be 0.
+    let initial_lazy_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
     assert_eq!(initial_lazy_nonce, 0, "Initial lazy inbound nonce should be 0");
 
-    // Initially, inbound nonce should be 0
+    // Initially, inbound nonce should be 0.
     let initial_nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
     assert_eq!(initial_nonce, 0);
 
-    // Skip nonce 1 (expected nonce is initial_nonce + 1 = 1)
-    endpoint_client
-        .mock_auths(&[soroban_sdk::testutils::MockAuth {
-            address: &receiver,
-            invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                contract: &endpoint_client.address,
-                fn_name: "skip",
-                args: (&receiver, &receiver, &src_eid, &sender, &nonce).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .skip(&receiver, &receiver, &src_eid, &sender, &nonce);
-
-    // Verify InboundNonceSkipped event was emitted
+    // Skip nonce 1 (expected nonce is initial_nonce + 1 = 1).
+    skip_with_auth(&context, &receiver, &receiver, src_eid, &sender, nonce);
+
+    // Verify InboundNonceSkipped event was emitted.
     assert_event(
         env,
         &endpoint_client.address,
         InboundNonceSkipped { src_eid, sender: sender.clone(), receiver: receiver.clone(), nonce },
     );
 
-    // Verify inbound nonce reflects the skip via public interface
+    // Verify inbound nonce reflects the skip via public interface.
     let updated_nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
     assert_eq!(updated_nonce, nonce);
 
-    // Assert storage change directly - lazy inbound 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, "Storage should contain updated lazy inbound nonce");
+    // Verify lazy inbound nonce was updated.
+    let lazy_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(lazy_nonce, nonce);
 }
 
+// Multiple sequential skips update to the latest nonce
 #[test]
 fn test_skip_multiple_nonces() {
-    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 receiver = Address::generate(env);
     let src_eid = 2;
     let sender = BytesN::from_array(env, &[1u8; 32]);
 
-    // Skip nonce 1
+    // Skip nonce 1.
     let nonce1 = 1;
-    endpoint_client
-        .mock_auths(&[soroban_sdk::testutils::MockAuth {
-            address: &receiver,
-            invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                contract: &endpoint_client.address,
-                fn_name: "skip",
-                args: (&receiver, &receiver, &src_eid, &sender, &nonce1).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .skip(&receiver, &receiver, &src_eid, &sender, &nonce1);
-
-    // Skip nonce 2
+    skip_with_auth(&context, &receiver, &receiver, src_eid, &sender, nonce1);
+
+    // Skip nonce 2.
     let nonce2 = 2;
-    endpoint_client
-        .mock_auths(&[soroban_sdk::testutils::MockAuth {
-            address: &receiver,
-            invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                contract: &endpoint_client.address,
-                fn_name: "skip",
-                args: (&receiver, &receiver, &src_eid, &sender, &nonce2).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .skip(&receiver, &receiver, &src_eid, &sender, &nonce2);
-
-    // Verify lazy inbound nonce was updated to nonce2
-    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
-    });
+    skip_with_auth(&context, &receiver, &receiver, src_eid, &sender, nonce2);
+
+    // Verify lazy inbound nonce was updated to nonce2.
+    let lazy_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
     assert_eq!(lazy_nonce, nonce2);
 
-    // Verify inbound nonce reflects the latest skip
+    // Verify inbound nonce reflects the latest skip.
     let updated_nonce = endpoint_client.inbound_nonce(&receiver, &src_eid, &sender);
     assert_eq!(updated_nonce, nonce2);
 }
 
+// Delegate authorization (delegate(receiver) is allowed)
 #[test]
 fn test_skip_with_delegate() {
-    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 receiver = Address::generate(env);
     let delegate = Address::generate(env);
@@ -116,41 +133,30 @@ fn test_skip_with_delegate() {
     let sender = BytesN::from_array(env, &[1u8; 32]);
     let nonce = 1;
 
-    // Set delegate for receiver
+    // Set delegate for receiver.
     env.as_contract(&endpoint_client.address, || storage::EndpointStorage::set_delegate(env, &receiver, &delegate));
 
-    // Delegate can skip 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: "skip",
-                args: (&delegate, &receiver, &src_eid, &sender, &nonce).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .skip(&delegate, &receiver, &src_eid, &sender, &nonce);
-
-    // Verify InboundNonceSkipped event was emitted
+    // Delegate can skip on behalf of receiver.
+    skip_with_auth(&context, &delegate, &receiver, src_eid, &sender, nonce);
+
+    // Verify InboundNonceSkipped event was emitted.
     assert_event(
         env,
         &endpoint_client.address,
         InboundNonceSkipped { src_eid, sender: sender.clone(), receiver: receiver.clone(), nonce },
     );
 
-    // Verify lazy inbound nonce was updated
-    let lazy_nonce = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
-    });
+    // Verify lazy inbound nonce was updated.
+    let lazy_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
     assert_eq!(lazy_nonce, nonce);
 }
 
+// Path isolation (receiver/src_eid/sender are isolated)
 #[test]
 fn test_skip_different_paths() {
-    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 receiver1 = Address::generate(env);
     let receiver2 = Address::generate(env);
@@ -160,73 +166,115 @@ fn test_skip_different_paths() {
     let sender2 = BytesN::from_array(env, &[2u8; 32]);
     let nonce = 1;
 
-    // Skip for different receivers
-    endpoint_client
-        .mock_auths(&[soroban_sdk::testutils::MockAuth {
-            address: &receiver1,
-            invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                contract: &endpoint_client.address,
-                fn_name: "skip",
-                args: (&receiver1, &receiver1, &src_eid1, &sender1, &nonce).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .skip(&receiver1, &receiver1, &src_eid1, &sender1, &nonce);
-
-    endpoint_client
-        .mock_auths(&[soroban_sdk::testutils::MockAuth {
-            address: &receiver2,
-            invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                contract: &endpoint_client.address,
-                fn_name: "skip",
-                args: (&receiver2, &receiver2, &src_eid1, &sender1, &nonce).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .skip(&receiver2, &receiver2, &src_eid1, &sender1, &nonce);
-
-    // Skip 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: "skip",
-                args: (&receiver1, &receiver1, &src_eid2, &sender1, &nonce).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .skip(&receiver1, &receiver1, &src_eid2, &sender1, &nonce);
-
-    // Skip for different senders
-    endpoint_client
-        .mock_auths(&[soroban_sdk::testutils::MockAuth {
-            address: &receiver1,
-            invoke: &soroban_sdk::testutils::MockAuthInvoke {
-                contract: &endpoint_client.address,
-                fn_name: "skip",
-                args: (&receiver1, &receiver1, &src_eid1, &sender2, &nonce).into_val(env),
-                sub_invokes: &[],
-            },
-        }])
-        .skip(&receiver1, &receiver1, &src_eid1, &sender2, &nonce);
-
-    // Verify all paths have independent lazy nonces
-    let lazy_nonce1 = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver1, src_eid1, &sender1)
-    });
-    let lazy_nonce2 = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver2, src_eid1, &sender1)
-    });
-    let lazy_nonce3 = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver1, src_eid2, &sender1)
-    });
-    let lazy_nonce4 = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver1, src_eid1, &sender2)
-    });
-
-    assert_eq!(lazy_nonce1, nonce);
-    assert_eq!(lazy_nonce2, nonce);
-    assert_eq!(lazy_nonce3, nonce);
-    assert_eq!(lazy_nonce4, nonce);
+    // Skip for different receivers.
+    skip_with_auth(&context, &receiver1, &receiver1, src_eid1, &sender1, nonce);
+    skip_with_auth(&context, &receiver2, &receiver2, src_eid1, &sender1, nonce);
+
+    // Skip for different src_eids.
+    skip_with_auth(&context, &receiver1, &receiver1, src_eid2, &sender1, nonce);
+
+    // Skip for different senders.
+    skip_with_auth(&context, &receiver1, &receiver1, src_eid1, &sender2, nonce);
+
+    // Verify all paths have independent lazy nonces.
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver1, &src_eid1, &sender1), nonce);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver2, &src_eid1, &sender1), nonce);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver1, &src_eid2, &sender1), nonce);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver1, &src_eid1, &sender2), nonce);
+}
+
+// Invalid nonce rejection (must match expected nonce)
+#[test]
+fn test_skip_invalid_nonce() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Expected nonce is 1; skipping 2 should fail.
+    let invalid_nonce = 2u64;
+
+    context.mock_auth(&receiver, "skip", (&receiver, &receiver, &src_eid, &sender, &invalid_nonce));
+    let result = endpoint_client.try_skip(&receiver, &receiver, &src_eid, &sender, &invalid_nonce);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InvalidNonce.into());
+}
+
+// Next nonce is derived from inbound_nonce (includes verified payload hashes)
+#[test]
+fn test_skip_next_nonce_accounts_for_verified_payload_hashes() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Simulate a verified message at nonce 1.
+    let payload_hash_1 = BytesN::from_array(env, &[0xabu8; 32]);
+    context.inbound_as_verified(&receiver, src_eid, &sender, 1, &payload_hash_1);
+
+    // Now inbound_nonce is 1, so the next nonce to skip must be 2 (not 1).
+    assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 1);
+
+    context.mock_auth(&receiver, "skip", (&receiver, &receiver, &src_eid, &sender, &1u64));
+    let result = endpoint_client.try_skip(&receiver, &receiver, &src_eid, &sender, &1);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InvalidNonce.into());
+
+    // Skipping 2 should succeed and advance lazy inbound nonce to 2.
+    skip_with_auth(&context, &receiver, &receiver, src_eid, &sender, 2);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 2);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 2);
+
+    // skip() does not clear any existing payload hashes.
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &1), Some(payload_hash_1));
+}
+
+// Skipping a missing nonce can "close the gap" and advance inbound_nonce
+#[test]
+fn test_skip_closes_gap_and_advances_inbound_nonce() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Only nonce 2 is verified, so inbound_nonce is still 0 (there is a gap at nonce 1).
+    let payload_hash_2 = BytesN::from_array(env, &[0xcdu8; 32]);
+    context.inbound_as_verified(&receiver, src_eid, &sender, 2, &payload_hash_2);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 0);
+
+    // Skip nonce 1 to close the gap. This should allow inbound_nonce to advance to 2.
+    skip_with_auth(&context, &receiver, &receiver, src_eid, &sender, 1);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 1);
+    assert_eq!(endpoint_client.inbound_nonce(&receiver, &src_eid, &sender), 2);
+
+    // Payload hash at nonce 2 remains intact.
+    assert_eq!(endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &2), Some(payload_hash_2));
+}
+
+// Repeated skip of the same nonce is rejected
+#[test]
+fn test_skip_rejects_repeated_same_nonce() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let receiver = Address::generate(env);
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // Skip nonce 1 successfully.
+    skip_with_auth(&context, &receiver, &receiver, src_eid, &sender, 1);
+    assert_eq!(endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender), 1);
+
+    // Skipping nonce 1 again should fail since the next expected nonce is now 2.
+    context.mock_auth(&receiver, "skip", (&receiver, &receiver, &src_eid, &sender, &1u64));
+    let result = endpoint_client.try_skip(&receiver, &receiver, &src_eid, &sender, &1);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InvalidNonce.into());
 }