@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/message-libs/uln-302/src/tests/receive_uln302/confirmations.rs

@@ -0,0 +1,128 @@
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, IntoVal,
+};
+
+use crate::{
+    interfaces::ReceiveUln302Client,
+    tests::setup::{setup, TestSetup},
+};
+
+use super::{create_test_packet_header, create_test_payload_hash, CONFIRMATIONS};
+
+#[test]
+fn test_verification_returns_stored_data() {
+    let TestSetup { env, uln302, .. } = setup();
+    let dvn = Address::generate(&env);
+    let receiver = Address::generate(&env);
+
+    let packet_header = create_test_packet_header(&env, &receiver);
+    let payload_hash = create_test_payload_hash(&env);
+
+    let receive_client = ReceiveUln302Client::new(&env, &uln302.address);
+
+    // Mock DVN auth and verify
+    env.mock_auths(&[MockAuth {
+        address: &dvn,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "verify",
+            args: (&dvn, &packet_header, &payload_hash, &CONFIRMATIONS).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_client.verify(&dvn, &packet_header, &payload_hash, &CONFIRMATIONS);
+
+    // Query the verification
+    let header_hash = endpoint_v2::util::keccak256(&env, &packet_header);
+    let confirmations = receive_client.confirmations(&dvn, &header_hash, &payload_hash);
+
+    assert!(confirmations.is_some());
+    assert_eq!(confirmations.unwrap(), CONFIRMATIONS);
+}
+
+#[test]
+fn test_verification_returns_none_for_missing() {
+    let TestSetup { env, uln302, .. } = setup();
+    let dvn = Address::generate(&env);
+    let receiver = Address::generate(&env);
+
+    let packet_header = create_test_packet_header(&env, &receiver);
+    let payload_hash = create_test_payload_hash(&env);
+
+    let receive_client = ReceiveUln302Client::new(&env, &uln302.address);
+
+    // Query verification without storing any
+    let header_hash = endpoint_v2::util::keccak256(&env, &packet_header);
+    let confirmations = receive_client.confirmations(&dvn, &header_hash, &payload_hash);
+    assert!(confirmations.is_none());
+}
+
+#[test]
+fn test_verification_after_multiple_dvns() {
+    let TestSetup { env, uln302, .. } = setup();
+    let dvn1 = Address::generate(&env);
+    let dvn2 = Address::generate(&env);
+    let dvn3 = Address::generate(&env);
+    let receiver = Address::generate(&env);
+
+    let packet_header = create_test_packet_header(&env, &receiver);
+    let payload_hash = create_test_payload_hash(&env);
+
+    let confirmations1 = 25u64;
+    let confirmations2 = 30u64;
+    let confirmations3 = 35u64;
+
+    let receive_client = ReceiveUln302Client::new(&env, &uln302.address);
+
+    // DVN1 verifies
+    env.mock_auths(&[MockAuth {
+        address: &dvn1,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "verify",
+            args: (&dvn1, &packet_header, &payload_hash, &confirmations1).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_client.verify(&dvn1, &packet_header, &payload_hash, &confirmations1);
+
+    // DVN2 verifies
+    env.mock_auths(&[MockAuth {
+        address: &dvn2,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "verify",
+            args: (&dvn2, &packet_header, &payload_hash, &confirmations2).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_client.verify(&dvn2, &packet_header, &payload_hash, &confirmations2);
+
+    // DVN3 verifies
+    env.mock_auths(&[MockAuth {
+        address: &dvn3,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "verify",
+            args: (&dvn3, &packet_header, &payload_hash, &confirmations3).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    receive_client.verify(&dvn3, &packet_header, &payload_hash, &confirmations3);
+
+    // Query each DVN's verification separately
+    let header_hash = endpoint_v2::util::keccak256(&env, &packet_header);
+
+    let received_confirmations1 = receive_client.confirmations(&dvn1, &header_hash, &payload_hash);
+    assert!(received_confirmations1.is_some());
+    assert_eq!(received_confirmations1.unwrap(), confirmations1);
+
+    let received_confirmations2 = receive_client.confirmations(&dvn2, &header_hash, &payload_hash);
+    assert!(received_confirmations2.is_some());
+    assert_eq!(received_confirmations2.unwrap(), confirmations2);
+
+    let received_confirmations3 = receive_client.confirmations(&dvn3, &header_hash, &payload_hash);
+    assert!(received_confirmations3.is_some());
+    assert_eq!(received_confirmations3.unwrap(), confirmations3);
+}

package/contracts/message-libs/uln-302/src/tests/receive_uln302/effective_receive_uln_config.rs

@@ -0,0 +1,104 @@
+extern crate std;
+use crate::{
+    errors::Uln302Error,
+    events::UlnReceiveConfigSet,
+    interfaces::{OAppUlnConfig, UlnConfig},
+    tests::setup::{setup, TestSetup},
+    uln302::CONFIG_TYPE_RECEIVE_ULN,
+};
+use endpoint_v2::SetConfigParam;
+use soroban_sdk::{log, testutils::Address as _, vec, xdr::ToXdr, Address, Env};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_effective_receive_uln_config_with_default_only() {
+    let setup = setup();
+
+    let default_config = UlnConfig::generate(&setup.env, 15, 1, 2, 1);
+    let eid = 101;
+
+    setup.set_default_receive_uln_config(eid, default_config.clone());
+
+    let TestSetup { env, uln302, .. } = setup;
+
+    let oapp = Address::generate(&env);
+    log!(&env, "oapp: {}", oapp);
+
+    let config = uln302.effective_receive_uln_config(&oapp, &eid);
+    assert_eq!(config, default_config);
+}
+
+#[test]
+fn test_effective_receive_uln_config_with_custom_config() {
+    let setup = setup();
+
+    let default_config = UlnConfig::generate(&setup.env, 15, 1, 2, 1);
+    let eid = 101;
+
+    setup.set_default_send_uln_config(eid, default_config.clone());
+    setup.set_default_receive_uln_config(eid, default_config.clone());
+
+    let TestSetup { env, uln302, endpoint, .. } = setup;
+
+    let oapp = Address::generate(&env);
+
+    // Custom config that uses default confirmations but custom DVNs
+    let custom_config = OAppUlnConfig {
+        use_default_confirmations: true,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: false,
+        uln_config: UlnConfig::generate(&env, 0, 3, 1, 1),
+    };
+
+    let expected_required_dvns = custom_config.uln_config.required_dvns.clone();
+    let expected_optional_dvns = custom_config.uln_config.optional_dvns.clone();
+
+    let config_bytes = custom_config.clone().to_xdr(&env);
+    let params = vec![&env, SetConfigParam { eid, config_type: CONFIG_TYPE_RECEIVE_ULN, config: config_bytes }];
+    endpoint.set_config(&Address::generate(&env), &oapp, &uln302.address, &params);
+
+    // Assert UlnReceiveConfigSet event was published immediately after the setter
+    assert_event(
+        &env,
+        &uln302.address,
+        UlnReceiveConfigSet { config: custom_config.clone(), receiver: oapp.clone(), src_eid: eid },
+    );
+
+    let config = uln302.effective_receive_uln_config(&oapp, &eid);
+    assert_eq!(config.confirmations, default_config.confirmations);
+    assert_eq!(config.required_dvns, expected_required_dvns);
+    assert_eq!(config.optional_dvns, expected_optional_dvns);
+}
+
+#[test]
+fn test_effective_receive_uln_config_must_have_at_least_one_dvn() {
+    let setup = setup();
+
+    let default_config = UlnConfig::generate(&setup.env, 10, 1, 0, 0);
+    let eid = 101;
+
+    setup.set_default_receive_uln_config(eid, default_config.clone());
+    setup.set_default_send_uln_config(eid, default_config);
+
+    let TestSetup { env, uln302, endpoint, .. } = setup;
+
+    let oapp = Address::generate(&env);
+    log!(&env, "oapp: {}", oapp);
+
+    let custom_config = OAppUlnConfig {
+        use_default_confirmations: true,
+        use_default_required_dvns: false,
+        use_default_optional_dvns: false,
+        uln_config: UlnConfig {
+            confirmations: 0,
+            required_dvns: vec![&env],
+            optional_dvns: vec![&env],
+            optional_dvn_threshold: 0,
+        },
+    };
+
+    let config_bytes = custom_config.to_xdr(&env);
+    let params = vec![&env, SetConfigParam { eid, config_type: CONFIG_TYPE_RECEIVE_ULN, config: config_bytes }];
+    let result = endpoint.try_set_config(&Address::generate(&env), &oapp, &uln302.address, &params);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::UlnAtLeastOneDVN.into());
+}

package/contracts/message-libs/uln-302/src/tests/receive_uln302/mod.rs

@@ -0,0 +1,66 @@
+mod commit_verification;
+mod confirmations;
+mod effective_receive_uln_config;
+mod set_default_receive_uln_configs;
+mod verifiable;
+mod verify;
+
+// Helper functions for receive tests
+use endpoint_v2::OutboundPacket;
+use message_lib_common::packet_codec_v1;
+use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, Address, Bytes, BytesN, Env};
+
+use crate::tests::setup::{LOCAL_EID, REMOTE_EID};
+
+/// Helper to extract BytesN<32> payload from an Address
+fn address_to_bytes32(address: &Address) -> BytesN<32> {
+    match address.to_payload().unwrap() {
+        AddressPayload::AccountIdPublicKeyEd25519(payload) => payload,
+        AddressPayload::ContractIdHash(payload) => payload,
+    }
+}
+
+pub const NONCE: u64 = 12345;
+pub const CONFIRMATIONS: u64 = 20;
+
+/// Creates a valid test packet header
+pub fn create_test_packet_header(env: &Env, receiver: &Address) -> Bytes {
+    let sender = Address::generate(env);
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let message = Bytes::from_array(env, &[0x01, 0x02, 0x03, 0x04]);
+
+    let packet = OutboundPacket {
+        nonce: NONCE,
+        src_eid: REMOTE_EID,
+        sender: sender.clone(),
+        dst_eid: LOCAL_EID,
+        receiver: address_to_bytes32(receiver),
+        guid,
+        message,
+    };
+    packet_codec_v1::encode_packet_header(env, &packet)
+}
+
+/// Creates a test packet header with custom EID (for invalid EID tests)
+pub fn create_test_packet_header_with_eid(env: &Env, receiver: &Address, dst_eid: u32) -> Bytes {
+    let sender = Address::generate(env);
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let message = Bytes::from_array(env, &[0x01, 0x02, 0x03, 0x04]);
+
+    let packet = OutboundPacket {
+        nonce: NONCE,
+        src_eid: REMOTE_EID,
+        sender: sender.clone(),
+        dst_eid,
+        receiver: address_to_bytes32(receiver),
+        guid,
+        message,
+    };
+    packet_codec_v1::encode_packet_header(env, &packet)
+}
+
+/// Creates a test payload hash
+pub fn create_test_payload_hash(env: &Env) -> BytesN<32> {
+    let random_data = Bytes::from_array(env, &[0xde, 0xad, 0xbe, 0xef]);
+    endpoint_v2::util::keccak256(env, &random_data)
+}

package/contracts/message-libs/uln-302/src/tests/receive_uln302/set_default_receive_uln_configs.rs

@@ -0,0 +1,79 @@
+extern crate std;
+use crate::{
+    errors::Uln302Error,
+    events::DefaultUlnReceiveConfigSet,
+    interfaces::{ReceiveUln302Client, SetDefaultUlnConfigParam, UlnConfig},
+    tests::setup::{setup, TestSetup},
+};
+use soroban_sdk::{
+    testutils::{MockAuth, MockAuthInvoke},
+    vec, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_set_default_receive_uln_configs() {
+    let TestSetup { env, uln302, owner, .. } = setup();
+
+    let oapp_receive_uln_configs = vec![
+        &env,
+        SetDefaultUlnConfigParam { dst_eid: 100, config: UlnConfig::generate(&env, 1, 1, 3, 1) },
+        SetDefaultUlnConfigParam { dst_eid: 101, config: UlnConfig::generate(&env, 2, 1, 3, 1) },
+    ];
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &uln302.address,
+            fn_name: "set_default_receive_uln_configs",
+            args: (&oapp_receive_uln_configs,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    uln302.set_default_receive_uln_configs(&oapp_receive_uln_configs);
+
+    // Assert DefaultUlnReceiveConfigSet event was published with all params
+    assert_event(&env, &uln302.address, DefaultUlnReceiveConfigSet { params: oapp_receive_uln_configs.clone() });
+
+    let uln302_receive_client = ReceiveUln302Client::new(&env, &uln302.address);
+    for config in oapp_receive_uln_configs.clone() {
+        assert_eq!(uln302_receive_client.default_receive_uln_config(&config.dst_eid), Some(config.config));
+    }
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_default_receive_uln_configs_authorization() {
+    let TestSetup { env, uln302, .. } = setup();
+
+    let oapp_receive_uln_configs =
+        vec![&env, SetDefaultUlnConfigParam { dst_eid: 100, config: UlnConfig::generate(&env, 1, 1, 3, 1) }];
+
+    uln302.set_default_receive_uln_configs(&oapp_receive_uln_configs);
+}
+
+#[test]
+fn test_set_default_receive_uln_configs_assert_default_config() {
+    let TestSetup { env, uln302, .. } = setup();
+
+    let mut config = UlnConfig::generate(&env, 1, 1, 3, 1);
+    config.required_dvns.push_back(config.required_dvns.get(0).unwrap().clone());
+    let oapp_receive_uln_configs = vec![&env, SetDefaultUlnConfigParam { dst_eid: 100, config }];
+
+    env.mock_all_auths();
+    let result = uln302.try_set_default_receive_uln_configs(&oapp_receive_uln_configs);
+    assert_eq!(result.err().unwrap().ok().unwrap(), Uln302Error::DuplicateRequiredDVNs.into());
+}
+
+#[test]
+fn test_default_receive_uln_config_not_found() {
+    // Sui equivalent: test_get_default_config_not_found (from receive_uln_tests.move)
+    // Attempt to get ULN config without setting it first
+    let TestSetup { env, uln302, .. } = setup();
+
+    let uln302_receive_client = ReceiveUln302Client::new(&env, &uln302.address);
+
+    // Try to get default config for an EID that hasn't been configured
+    let config = uln302_receive_client.default_receive_uln_config(&999);
+    assert_eq!(config, None);
+}