@layerzerolabs/protocol-stellar-v2 0.2.20 → 0.2.22

package/contracts/endpoint-v2/src/tests/messaging_composer/lz_compose_alert.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{
     constants::MAX_COMPOSE_INDEX, endpoint_v2::EndpointV2Client, errors::EndpointError, events::LzComposeAlert,
@@ -81,7 +81,7 @@ fn test_lz_compose_alert_auth() {
         &f.reason,
     );
 
-    assert_event(
+    assert_eq_event(
         env,
         &endpoint_client.address,
         LzComposeAlert {
@@ -192,7 +192,7 @@ fn test_lz_compose_alert_with_empty_data() {
         &f.reason,
     );
 
-    assert_event(
+    assert_eq_event(
         env,
         &endpoint_client.address,
         LzComposeAlert {

package/contracts/endpoint-v2/src/tests/messaging_composer/send_compose.rs

@@ -1,5 +1,5 @@
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_eq_event;
 
 use crate::{
     constants::MAX_COMPOSE_INDEX, errors::EndpointError, events::ComposeSent, tests::endpoint_setup::setup,
@@ -85,7 +85,7 @@ fn test_send_compose_success() {
     context.send_compose_with_auth(&from, &to, &guid, index, &message);
 
     // Verify the event was published.
-    assert_event(
+    assert_eq_event(
         env,
         &endpoint_client.address,
         ComposeSent { from: from.clone(), to: to.clone(), guid: guid.clone(), index, message: message.clone() },

package/contracts/layerzero-views/Cargo.toml

@@ -18,7 +18,6 @@ testnet = []
 sandbox = []
 
 [dependencies]
-cfg-if = { workspace = true }
 soroban-sdk = { workspace = true }
 # workspace dependencies
 utils = { workspace = true }

package/contracts/layerzero-views/src/layerzero_view.rs

@@ -14,9 +14,8 @@ use endpoint_v2::{LayerZeroEndpointV2Client, MessageLibManagerClient, MessagingC
 use message_lib_common::packet_codec_v1::{decode_packet_header, PacketHeader};
 use soroban_sdk::{address_payload::AddressPayload, assert_with_error, Address, Bytes, BytesN, Env};
 use uln302::ReceiveUln302Client;
-use utils::upgradeable::UpgradeableInternal;
 
-#[lz_contract(upgradeable)]
+#[lz_contract(upgradeable(no_migration))]
 pub struct LayerZeroView;
 
 #[contract_impl]
@@ -213,14 +212,3 @@ impl LayerZeroView {
     }
 }
 
-// ============================================================================
-// Upgradeable Implementation
-// ============================================================================
-
-impl UpgradeableInternal for LayerZeroView {
-    type MigrationData = ();
-
-    fn __migrate(_env: &Env, _migration_data: &Self::MigrationData) {
-        // No migration logic needed for initial upgrade capability
-    }
-}

package/contracts/macro-integration-tests/Cargo.toml

@@ -10,21 +10,11 @@ publish = false
 # The lib.rs provides shared testing utilities.
 doctest = false
 
-[dependencies]
-soroban-sdk = { workspace = true }
-
-# Macro crates to be tested
-common-macros = { workspace = true }
-oapp-macros = { workspace = true }
-# oft-macros = { workspace = true }  # TODO: Add when available
-
-# Runtime libraries (for verifying generated code behavior)
-utils = { workspace = true }
-oapp = { workspace = true }
-# oft = { workspace = true }  # TODO: Add when available
-endpoint-v2 = { workspace = true, features = ["library"] }
-
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
+trybuild = { workspace = true }
+common-macros = { workspace = true }
 utils = { workspace = true, features = ["testutils"] }
-trybuild = "1.0.114"
+endpoint-v2 = { workspace = true, features = ["testutils"] }
+oapp = { workspace = true }
+oapp-macros = { workspace = true }

package/contracts/macro-integration-tests/tests/runtime/oapp/mod.rs

@@ -0,0 +1,48 @@
+use endpoint_v2::Origin;
+use oapp::oapp_receiver::LzReceiveInternal;
+use oapp_macros::oapp;
+use soroban_sdk::{contractimpl, symbol_short, Address, Bytes, BytesN, Env};
+
+mod oapp_core;
+mod options_type3;
+mod receiver;
+mod sender;
+
+/// Shared contract used by oapp-macros runtime tests.
+///
+/// Notes:
+/// - `#[oapp]` expands to `#[common_macros::lz_contract]` + default trait impls for:
+///   - `oapp::oapp_core::OAppCore` (contract trait)
+///   - `oapp::oapp_receiver::OAppReceiver` (contract trait)
+///   - `oapp::oapp_options_type3::OAppOptionsType3` (contract trait)
+///   - `oapp::oapp_sender::OAppSenderInternal` (internal trait)
+#[oapp]
+pub struct TestOApp;
+
+impl LzReceiveInternal for TestOApp {
+    fn __lz_receive(
+        env: &Env,
+        _origin: &Origin,
+        _guid: &BytesN<32>,
+        _message: &Bytes,
+        _extra_data: &Bytes,
+        _executor: &Address,
+        _value: i128,
+    ) {
+        // Mark that the internal handler was invoked.
+        env.storage().instance().set(&symbol_short!("lzr_c"), &true);
+    }
+}
+
+#[contractimpl]
+impl TestOApp {
+    /// Initializes owner and stores an endpoint address for `OAppCore::endpoint`.
+    pub fn init(env: Env, owner: Address, endpoint: Address) {
+        Self::init_owner(&env, &owner);
+        oapp::oapp_core::OAppCoreStorage::set_endpoint(&env, &endpoint);
+    }
+
+    pub fn lz_receive_called(env: Env) -> bool {
+        env.storage().instance().get(&symbol_short!("lzr_c")).unwrap_or(false)
+    }
+}

package/contracts/macro-integration-tests/tests/runtime/oapp/oapp_core.rs

@@ -0,0 +1,170 @@
+// Runtime tests: OAppCore behavior generated by `#[oapp]`.
+
+use super::{TestOApp, TestOAppClient};
+use oapp::oapp_core::{OAppCoreStorage, PeerSet};
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    xdr::{ScErrorCode, ScErrorType},
+    Address, BytesN, Env, Error, IntoVal,
+};
+use utils::testing_utils::assert_contains_event;
+
+/// Minimal endpoint stub used to verify `OAppCore::set_delegate` forwards calls.
+#[contract]
+pub struct MockEndpoint;
+
+#[contractimpl]
+impl MockEndpoint {
+    pub fn set_delegate(env: Env, oapp: Address, new_delegate: Option<Address>) {
+        if let Some(d) = new_delegate {
+            env.storage().instance().set(&oapp, &d);
+        } else {
+            env.storage().instance().remove(&oapp);
+        }
+    }
+
+    pub fn delegate(env: Env, oapp: Address) -> Option<Address> {
+        env.storage().instance().get(&oapp)
+    }
+}
+
+#[test]
+fn oapp_version_default() {
+    let env = Env::default();
+    let contract_id = env.register(TestOApp, ());
+    let client = TestOAppClient::new(&env, &contract_id);
+
+    // Default `OAppCore::oapp_version` should be callable without initialization.
+    assert_eq!(client.oapp_version(), (1u64, 1u64));
+}
+
+#[test]
+fn endpoint_roundtrip() {
+    let env = Env::default();
+    let contract_id = env.register(TestOApp, ());
+    let client = TestOAppClient::new(&env, &contract_id);
+
+    // Before init, `endpoint()` unwraps storage and should fail.
+    assert!(client.try_endpoint().is_err());
+
+    let owner = Address::generate(&env);
+    let endpoint = Address::generate(&env);
+    client.init(&owner, &endpoint);
+
+    assert_eq!(client.endpoint(), endpoint);
+}
+
+#[test]
+fn set_peer_requires_auth_and_updates_storage() {
+    let env = Env::default();
+    let contract_id = env.register(TestOApp, ());
+    let client = TestOAppClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    let endpoint = Address::generate(&env);
+    client.init(&owner, &endpoint);
+
+    let eid: u32 = 101;
+    let peer = Some(BytesN::<32>::from_array(&env, &[7u8; 32]));
+
+    // Peer is None when unset.
+    assert_eq!(client.peer(&eid), None);
+
+    // Unauthorized set should fail.
+    let unauthorized = client.try_set_peer(&eid, &peer);
+    assert_eq!(
+        unauthorized.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // Authorized set should succeed.
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "set_peer",
+                args: (&eid, &peer).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .set_peer(&eid, &peer);
+
+    // Assert event before any other contract call (Soroban events are per-call).
+    assert_contains_event(&env, &contract_id, PeerSet { eid, peer: peer.clone() });
+
+    // Verify storage without issuing another contract call (so we don't clobber event log).
+    env.as_contract(&contract_id, || {
+        assert_eq!(OAppCoreStorage::peer(&env, eid), peer.clone());
+    });
+
+    // Remove peer by setting None.
+    let none: Option<BytesN<32>> = None;
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract_id,
+            fn_name: "set_peer",
+            args: (&eid, &none).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    client.set_peer(&eid, &none);
+    assert_contains_event(&env, &contract_id, PeerSet { eid, peer: None });
+    env.as_contract(&contract_id, || {
+        assert_eq!(OAppCoreStorage::peer(&env, eid), None);
+    });
+}
+
+#[test]
+fn set_delegate_requires_auth_and_updates_endpoint() {
+    let env = Env::default();
+    let contract_id = env.register(TestOApp, ());
+    let client = TestOAppClient::new(&env, &contract_id);
+
+    let endpoint_id = env.register(MockEndpoint, ());
+    let endpoint_client = MockEndpointClient::new(&env, &endpoint_id);
+
+    let owner = Address::generate(&env);
+    client.init(&owner, &endpoint_id);
+
+    // Unauthorized set should fail.
+    let delegate = Some(Address::generate(&env));
+    let unauthorized = client.try_set_delegate(&delegate);
+    assert_eq!(
+        unauthorized.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // Authorized set should succeed and forward to the endpoint.
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "set_delegate",
+                args: (&delegate,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .set_delegate(&delegate);
+
+    assert_eq!(endpoint_client.delegate(&contract_id), delegate);
+
+    // Authorized removal should clear the endpoint delegate.
+    let none: Option<Address> = None;
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "set_delegate",
+                args: (&none,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .set_delegate(&none);
+
+    assert_eq!(endpoint_client.delegate(&contract_id), None);
+}

package/contracts/macro-integration-tests/tests/runtime/oapp/options_type3.rs

@@ -0,0 +1,154 @@
+// Runtime tests: OAppOptionsType3 defaults generated by `#[oapp]`.
+
+use super::{TestOApp, TestOAppClient};
+use oapp::errors::OAppError;
+use oapp::oapp_options_type3::{EnforcedOptionParam, EnforcedOptionSet};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    vec, Address, Bytes, Env, IntoVal,
+};
+use utils::testing_utils::assert_contains_event;
+
+const OPTION_TYPE_3: u16 = 3;
+const REMOTE_EID_1: u32 = 100;
+const MSG_TYPE_SEND: u32 = 1;
+const MSG_TYPE_RECEIVE: u32 = 2;
+
+fn create_valid_options(env: &Env, data: &[u8]) -> Bytes {
+    let mut buffer = Bytes::from_array(env, &OPTION_TYPE_3.to_be_bytes());
+    buffer.extend_from_slice(data);
+    buffer
+}
+
+#[test]
+fn enforced_options_lifecycle_and_auth() {
+    let env = Env::default();
+    let contract_id = env.register(TestOApp, ());
+    let client = TestOAppClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    client.init(&owner, &Address::generate(&env));
+
+    // Unset returns empty bytes (storage default).
+    assert_eq!(client.enforced_options(&999, &999), Bytes::new(&env));
+
+    let enforced_1 = create_valid_options(&env, &[1, 2, 3, 4]);
+    let enforced_2 = create_valid_options(&env, &[5, 6, 7, 8]);
+    let params = vec![
+        &env,
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced_1.clone() },
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_RECEIVE, options: enforced_2.clone() },
+    ];
+
+    // Unauthorized set should fail (only_auth).
+    assert!(client.try_set_enforced_options(&params).is_err());
+
+    // Non-owner authorized should also fail.
+    let non_owner = Address::generate(&env);
+    env.mock_auths(&[MockAuth {
+        address: &non_owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract_id,
+            fn_name: "set_enforced_options",
+            args: (&params,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    assert!(client.try_set_enforced_options(&params).is_err());
+
+    // Owner-authorized set should succeed.
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract_id,
+            fn_name: "set_enforced_options",
+            args: (&params,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    client.set_enforced_options(&params);
+
+    assert_contains_event(&env, &contract_id, EnforcedOptionSet { enforced_option_params: params.clone() });
+
+    assert_eq!(client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), enforced_1);
+    assert_eq!(client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_RECEIVE), enforced_2);
+}
+
+#[test]
+fn set_enforced_options_rejects_invalid_option_type() {
+    let env = Env::default();
+    let contract_id = env.register(TestOApp, ());
+    let client = TestOAppClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    client.init(&owner, &Address::generate(&env));
+
+    // wrong type header (not 3)
+    let mut invalid = Bytes::from_array(&env, &(4u16).to_be_bytes());
+    invalid.extend_from_slice(&[1, 2, 3]);
+
+    let params = vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: invalid }];
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract_id,
+            fn_name: "set_enforced_options",
+            args: (&params,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    let result = client.try_set_enforced_options(&params);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
+}
+
+#[test]
+fn combine_options_behavior_and_validation() {
+    let env = Env::default();
+    let contract_id = env.register(TestOApp, ());
+    let client = TestOAppClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    client.init(&owner, &Address::generate(&env));
+
+    // No enforced => returns extra (including empty).
+    let extra_only = create_valid_options(&env, &[9, 10, 11]);
+    assert_eq!(client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra_only), extra_only);
+    let empty_extra = Bytes::new(&env);
+    assert_eq!(client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &empty_extra), empty_extra);
+
+    // Set enforced for (eid, msg_type).
+    let enforced = create_valid_options(&env, &[1, 2, 3, 4]);
+    let params =
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced.clone() }];
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &contract_id,
+            fn_name: "set_enforced_options",
+            args: (&params,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    client.set_enforced_options(&params);
+
+    // Enforced present: empty extra => enforced.
+    assert_eq!(client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &Bytes::new(&env)), enforced.clone());
+
+    // Both present: enforced + extra(without its 2-byte header).
+    let extra = create_valid_options(&env, &[4, 5, 6]);
+    let combined = client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra);
+    let expected = create_valid_options(&env, &[1, 2, 3, 4, 4, 5, 6]);
+    assert_eq!(combined, expected);
+
+    // Extra has wrong type (len >= 2) => InvalidOptions.
+    let mut extra_invalid = Bytes::from_array(&env, &(4u16).to_be_bytes());
+    extra_invalid.extend_from_slice(&[9, 9, 9]);
+    let bad = client.try_combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra_invalid);
+    assert_eq!(bad.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
+
+    // Extra non-empty but too short (<2) => InvalidOptions.
+    let too_short = Bytes::from_array(&env, &[1u8]);
+    let bad2 = client.try_combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &too_short);
+    assert_eq!(bad2.err().unwrap().ok().unwrap(), OAppError::InvalidOptions.into());
+}