@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/oapp-macros/src/oapp_receiver.rs

@@ -0,0 +1,67 @@
+use crate::{oapp_core, util::ManualImplConfig};
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Ident, ItemStruct};
+
+pub fn generate_impl(name: &Ident) -> TokenStream {
+    quote! {
+        use endpoint_v2::ILayerZeroReceiver as _;
+        use oapp::oapp_receiver::OAppReceiver as _;
+
+        #[soroban_sdk::contractimpl]
+        impl endpoint_v2::ILayerZeroReceiver for #name
+        {
+            fn allow_initialize_path(
+                env: &soroban_sdk::Env,
+                origin: &endpoint_v2::Origin,
+            ) -> bool {
+                <Self as oapp::oapp_receiver::OAppReceiverOverrides>::__allow_initialize_path(env, origin)
+            }
+
+            fn next_nonce(
+                env: &soroban_sdk::Env,
+                src_eid: u32,
+                sender: &soroban_sdk::BytesN<32>,
+            ) -> u64 {
+                <Self as oapp::oapp_receiver::OAppReceiverOverrides>::__next_nonce(env, src_eid, sender)
+            }
+
+            fn lz_receive(
+                env: &soroban_sdk::Env,
+                executor: &soroban_sdk::Address,
+                origin: &endpoint_v2::Origin,
+                guid: &soroban_sdk::BytesN<32>,
+                message: &soroban_sdk::Bytes,
+                extra_data: &soroban_sdk::Bytes,
+                value: i128,
+            ) {
+                oapp::oapp_receiver::verify_and_clear_payload::<Self>(env, executor, origin, guid, message);
+
+                <Self as oapp::oapp_receiver::OAppReceiverOverrides>::__lz_receive(
+                    env,
+                    executor,
+                    origin,
+                    guid,
+                    message,
+                    extra_data,
+                    value,
+                )
+            }
+        }
+
+        #[soroban_sdk::contractimpl]
+        impl oapp::oapp_receiver::OAppReceiver for #name
+        {
+            fn is_compose_msg_sender(env: &soroban_sdk::Env, origin: &endpoint_v2::Origin, message: &soroban_sdk::Bytes, sender: &soroban_sdk::Address) -> bool {
+                <Self as oapp::oapp_receiver::OAppReceiverOverrides>::__is_compose_msg_sender(env, origin, message, sender)
+            }
+        }
+    }
+}
+
+pub fn generate_impl_with_core(name: &Ident, item: ItemStruct, manual_impl_config: ManualImplConfig) -> TokenStream {
+    let mut oapp_core_impl = oapp_core::generate_impl(name, item, manual_impl_config.core);
+    let receiver_impl = generate_impl(name);
+    oapp_core_impl.extend(receiver_impl);
+    oapp_core_impl
+}

package/contracts/oapp-macros/src/oapp_sender.rs

@@ -0,0 +1,23 @@
+use crate::{oapp_core, util::ManualImplConfig};
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Ident, ItemStruct};
+
+pub fn generate_impl(name: &Ident, manual_impl_sender: bool) -> TokenStream {
+    if manual_impl_sender {
+        quote! {}
+    } else {
+        quote! {
+            use oapp::oapp_sender::OAppSenderOverrides as _;
+
+            impl oapp::oapp_sender::OAppSenderOverrides for #name {}
+        }
+    }
+}
+
+pub fn generate_impl_with_core(name: &Ident, item: ItemStruct, manual_impl_config: ManualImplConfig) -> TokenStream {
+    let mut oapp_core_impl = oapp_core::generate_impl(name, item, manual_impl_config.core);
+    let sender_impl = generate_impl(name, manual_impl_config.sender);
+    oapp_core_impl.extend(sender_impl);
+    oapp_core_impl
+}

package/contracts/oapp-macros/src/util.rs

@@ -0,0 +1,103 @@
+use proc_macro::TokenStream;
+use proc_macro2::Ident;
+use syn::{
+    parse::{Parse, ParseStream},
+    punctuated::Punctuated,
+    Error, ItemStruct, Token,
+};
+
+/// Configuration for which OApp trait implementations should be manually provided by the user.
+///
+/// This struct is parsed from the `#[oapp_manual_impl(...)]` attribute and controls
+/// which default trait implementations are generated by the macros.
+///
+/// # Fields
+/// * `core` - If `true`, the user must manually implement `OAppCoreOverrides`
+/// * `sender` - If `true`, the user must manually implement `OAppSenderOverrides`  
+/// * `options_type3` - If `true`, the user must manually implement `OAppOptionsType3Overrides`
+///
+/// # Note on Receiver
+/// There is intentionally **no** `receiver` field in this config because the receiver
+/// always requires manual implementation. The `OAppReceiverOverrides::__lz_receive` method
+/// has no default implementation, so users must always provide their own implementation
+/// of the message handling logic.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct ManualImplConfig {
+    pub core: bool,
+    pub sender: bool,
+    pub options_type3: bool,
+}
+
+impl ManualImplConfig {
+    /// Parses configuration from the `#[oapp_manual_impl(...)]` attribute arguments.
+    ///
+    /// Accepts a comma-separated list of identifiers: `core`, `sender`, `options_type3`.
+    /// Returns an error if any invalid identifier is provided.
+    fn from_attr(input: ParseStream) -> syn::Result<Self> {
+        let idents = Punctuated::<syn::Ident, Token![,]>::parse_terminated(input)?;
+
+        let mut cfg = ManualImplConfig::default();
+
+        for ident in idents {
+            match ident.to_string().as_str() {
+                "core" => cfg.core = true,
+                "sender" => cfg.sender = true,
+                "options_type3" => cfg.options_type3 = true,
+                _ => {
+                    return Err(Error::new(
+                        ident.span(),
+                        "invalid value for oapp_manual_impl: expected one of `core`, `sender`, `options_type3`",
+                    ));
+                }
+            }
+        }
+
+        Ok(cfg)
+    }
+}
+
+impl Parse for ManualImplConfig {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        ManualImplConfig::from_attr(input)
+    }
+}
+
+/// Parses a struct definition and extracts manual implementation configuration.
+///
+/// This function is used by all OApp macros to:
+/// 1. Parse the annotated item as a struct
+/// 2. Extract the struct name
+/// 3. Parse any `#[oapp_manual_impl(...)]` attributes to determine configuration
+///
+/// # Returns
+/// A tuple containing:
+/// * The struct identifier
+/// * The complete struct definition
+/// * The manual implementation configuration
+///
+/// # Errors
+/// Returns a compile error if:
+/// * The item is not a struct
+/// * The `#[oapp_manual_impl(...)]` attribute has invalid syntax
+pub fn parse_struct(item: TokenStream) -> Result<(Ident, ItemStruct, ManualImplConfig), TokenStream> {
+    let item_struct = syn::parse::<ItemStruct>(item).map_err(|e| e.to_compile_error())?;
+    let name = item_struct.ident.clone();
+
+    let mut cfg = ManualImplConfig::default();
+    // TODO: match at most once oapp_manual_impl attribute
+    for attr in item_struct.attrs.iter() {
+        if attr.path().is_ident("oapp_manual_impl") {
+            match attr.parse_args::<ManualImplConfig>() {
+                Ok(parsed) => {
+                    cfg = parsed;
+                }
+                Err(e) => {
+                    return Err(e.to_compile_error().into());
+                }
+            }
+            break;
+        }
+    }
+
+    Ok((name, item_struct, cfg))
+}