@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

package/contracts/oapps/oapp/src/oapp_sender.rs

@@ -1,11 +1,53 @@
 use crate::{
     errors::OAppError,
-    oapp_core::{endpoint_client, OAppCore},
+    oapp_core::{endpoint_client, get_peer_or_panic, OAppCore},
 };
 use endpoint_v2::{MessagingFee, MessagingParams, MessagingReceipt};
 use soroban_sdk::{token::TokenClient, Address, Bytes, Env};
 use utils::option_ext::OptionExt;
 
+/// The version of the OAppSender implementation.
+/// Version is bumped when changes are made to this contract.
+pub const SENDER_VERSION: u64 = 1;
+
+/// Represents a fee payer address with explicit authorization state.
+///
+/// This enum forces callers of `__lz_send` to explicitly declare whether
+/// `require_auth()` has already been called for the fee payer address.
+/// This prevents the common mistake of forgetting to authorize the fee payer.
+///
+/// # Variants
+/// - `Unverified` — Safe default. `__lz_send` will call `require_auth()` on the address.
+///   Use this when the caller has **not** already authorized the fee payer.
+/// - `Verified` — Caller asserts that `require_auth()` has already been called.
+///   Use this to avoid a duplicate `require_auth()` node in the Soroban auth tree
+///   (e.g., when the same address was already authorized as the message sender).
+#[derive(Clone)]
+pub enum FeePayer {
+    /// The fee payer has **not** been authorized yet.
+    /// `__lz_send` will call `fee_payer.require_auth()` before transferring fees.
+    /// This is the safe default — use this if unsure.
+    Unverified(Address),
+
+    /// The fee payer has **already** been authorized by the caller via `require_auth()`.
+    /// `__lz_send` will skip the auth check to avoid creating a duplicate auth node
+    /// in the Soroban authorization tree.
+    ///
+    /// # Safety
+    /// Only use this variant if you have already called `require_auth()` on this address
+    /// in the current contract invocation. Misuse may allow unauthorized fee deductions.
+    Verified(Address),
+}
+
+impl FeePayer {
+    /// Returns a reference to the underlying address.
+    pub fn address(&self) -> &Address {
+        match self {
+            FeePayer::Unverified(addr) | FeePayer::Verified(addr) => addr,
+        }
+    }
+}
+
 /// A helper trait for sending cross-chain messages via LayerZero.
 ///
 /// Contracts should implement this trait to gain access to the `__lz_quote` and `__lz_send` helper
@@ -29,7 +71,7 @@ pub trait OAppSenderInternal: OAppCore {
     /// # Returns
     /// * `MessagingFee`: The messaging fee for the message
     fn __quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
-        let receiver = Self::peer(env, dst_eid).unwrap_or_panic(env, OAppError::NoPeer);
+        let receiver = get_peer_or_panic::<Self>(env, dst_eid);
         endpoint_client::<Self>(env).quote(
             &env.current_contract_address(),
             &MessagingParams { dst_eid, receiver, message: message.clone(), options: options.clone(), pay_in_zro },
@@ -42,7 +84,9 @@ pub trait OAppSenderInternal: OAppCore {
     /// * `dst_eid`: The destination endpoint ID
     /// * `message`: The message to send
     /// * `options`: The options for the message
-    /// * `fee_payer`: The address of the payer for paying the messaging fees
+    /// * `fee_payer`: The fee payer, wrapped in [`FeePayer`] to indicate authorization state.
+    ///   Use `FeePayer::Unverified(addr)` if auth has not been checked (safe default),
+    ///   or `FeePayer::Verified(addr)` if `addr.require_auth()` was already called by the caller.
     /// * `fee`: The messaging fee
     /// * `refund_address`: The address to receive any excess fees
     ///
@@ -53,27 +97,34 @@ pub trait OAppSenderInternal: OAppCore {
         dst_eid: u32,
         message: &Bytes,
         options: &Bytes,
-        fee_payer: &Address,
+        fee_payer: &FeePayer,
         fee: &MessagingFee,
         refund_address: &Address,
     ) -> MessagingReceipt {
+        // Enforce fee payer authorization if not already verified by the caller
+        let payer = match fee_payer {
+            FeePayer::Unverified(addr) => {
+                addr.require_auth();
+                addr
+            }
+            FeePayer::Verified(addr) => addr,
+        };
+
         // Pay the messaging fees
-        Self::__pay_native(env, fee_payer, fee.native_fee);
-        if fee.zro_fee != 0 {
-            Self::__pay_zro(env, fee_payer, fee.zro_fee);
+        Self::__pay_native(env, payer, fee.native_fee);
+        // Skip the ZRO payment call only when the fee is exactly zero. Using `!= 0` instead of
+        // `> 0` so that an invalid negative value still reaches `__pay_zro` and fails loudly
+        // rather than being silently ignored.
+        let pay_in_zro = fee.zro_fee != 0;
+        if pay_in_zro {
+            Self::__pay_zro(env, payer, fee.zro_fee);
         }
 
         // Send the message to the other chain
-        let receiver = Self::peer(env, dst_eid).unwrap_or_panic(env, OAppError::NoPeer);
+        let receiver = get_peer_or_panic::<Self>(env, dst_eid);
         endpoint_client::<Self>(env).send(
             &env.current_contract_address(),
-            &MessagingParams {
-                dst_eid,
-                receiver,
-                message: message.clone(),
-                options: options.clone(),
-                pay_in_zro: fee.zro_fee > 0,
-            },
+            &MessagingParams { dst_eid, receiver, message: message.clone(), options: options.clone(), pay_in_zro },
             refund_address,
         )
     }

package/contracts/oapps/oapp/src/tests/oapp_core.rs

@@ -51,7 +51,7 @@ impl LzReceiveInternal for DummyOApp {
 #[contractimpl]
 impl DummyOApp {
     pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
-        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, &None);
+        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, owner);
     }
 }
 
@@ -111,18 +111,18 @@ fn set_delegate_with_auth(env: &Env, signer: &Address, oapp_client: &DummyOAppCl
 }
 
 #[test]
-fn test_constructor_initializes_owner_and_endpoint_and_clears_delegate() {
+fn test_constructor_initializes_owner_and_endpoint_and_delegate() {
     let TestSetup { env, owner, endpoint, oapp_client } = setup();
 
     // owner initialized via oapp_initialize -> init_owner
-    assert_eq!(Some(owner), oapp_client.owner());
+    assert_eq!(Some(owner.clone()), oapp_client.owner());
 
     // endpoint stored via OAppCoreStorage::set_endpoint
     assert_eq!(endpoint, oapp_client.endpoint());
 
-    // delegate set via oapp_initialize(..., &None) -> endpoint.set_delegate(..., None)
+    // delegate set via oapp_initialize(..., owner) -> endpoint.set_delegate(..., Some(owner))
     let endpoint_client = DummyEndpointClient::new(&env, &endpoint);
-    assert_eq!(None, endpoint_client.get_delegate(&oapp_client.address));
+    assert_eq!(Some(owner), endpoint_client.get_delegate(&oapp_client.address));
 }
 
 #[test]

package/contracts/oapps/oapp/src/tests/oapp_options_type3.rs

@@ -54,7 +54,7 @@ impl OAppReceiver for DummyOAppOptionsType3 {}
 
 #[contract_impl]
 impl DummyOAppOptionsType3 {
-    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Address) {
         oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, delegate);
     }
 }
@@ -70,7 +70,7 @@ fn setup<'a>() -> TestSetup<'a> {
 
     let owner = Address::generate(&env);
     let endpoint = env.register(DummyEndpoint, ());
-    let delegate: Option<Address> = Some(owner.clone());
+    let delegate = owner.clone();
     let oapp = env.register(DummyOAppOptionsType3, (&owner, &endpoint, &delegate));
     let oapp_client = DummyOAppOptionsType3Client::new(&env, &oapp);
 
@@ -105,33 +105,33 @@ fn set_enforced_options_with_auth(
 fn test_enforced_options_lifecycle() {
     let TestSetup { env, owner, oapp_client, .. } = setup();
 
-    // Unset returns empty
-    assert_eq!(oapp_client.enforced_options(&999, &999), Bytes::new(&env));
+    // Unset returns None
+    assert_eq!(oapp_client.enforced_options(&999, &999), None);
 
     // Set enforced options for different eid/msg_type combinations
     let enforced1 = create_valid_options(&env, &[1, 2, 3, 4]);
     let enforced2 = create_valid_options(&env, &[5, 6, 7, 8]);
     let enforced_params = vec![
         &env,
-        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced1.clone() },
-        EnforcedOptionParam { eid: REMOTE_EID_2, msg_type: MSG_TYPE_RECEIVE, options: enforced2.clone() },
+        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(enforced1.clone()) },
+        EnforcedOptionParam { eid: REMOTE_EID_2, msg_type: MSG_TYPE_RECEIVE, options: Some(enforced2.clone()) },
     ];
     set_enforced_options_with_auth(&env, &owner, &oapp_client, &enforced_params);
 
     // assert events
-    assert_eq_event(&env, &oapp_client.address, EnforcedOptionSet { enforced_option_params: enforced_params.clone() });
+    assert_eq_event(&env, &oapp_client.address, EnforcedOptionSet { enforced_options: enforced_params.clone() });
 
     // Verify options were set correctly
-    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), enforced1.clone());
-    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_2, &MSG_TYPE_RECEIVE), enforced2.clone());
+    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), Some(enforced1.clone()));
+    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_2, &MSG_TYPE_RECEIVE), Some(enforced2.clone()));
 
     // Update enforced options for one combination
     let updated = create_valid_options(&env, &[9, 8, 7, 6, 5]);
     let update_params =
-        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: updated.clone() }];
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(updated.clone()) }];
     set_enforced_options_with_auth(&env, &owner, &oapp_client, &update_params);
-    assert_eq_event(&env, &oapp_client.address, EnforcedOptionSet { enforced_option_params: update_params.clone() });
-    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), updated);
+    assert_eq_event(&env, &oapp_client.address, EnforcedOptionSet { enforced_options: update_params.clone() });
+    assert_eq!(oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND), Some(updated));
 }
 
 #[test]
@@ -148,7 +148,7 @@ fn test_combine_options() {
     // Set enforced options for the combine tests
     let enforced = create_valid_options(&env, &[1, 2, 3, 4]);
     let enforced_params =
-        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced.clone() }];
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(enforced.clone()) }];
     set_enforced_options_with_auth(&env, &owner, &oapp_client, &enforced_params);
 
     // combine_options: enforced present -> empty extra returns enforced
@@ -168,7 +168,7 @@ fn test_set_enforced_options_unauthorized() {
 
     let options = create_valid_options(&env, &[1, 2, 3, 4]);
     let enforced_params =
-        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: options.clone() }];
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(options.clone()) }];
     oapp_client.set_enforced_options(&enforced_params);
 }
 
@@ -181,7 +181,7 @@ fn test_set_enforced_options_non_owner_authorized() {
 
     let options = create_valid_options(&env, &[1, 2, 3, 4]);
     let enforced_params =
-        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: options.clone() }];
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(options.clone()) }];
 
     set_enforced_options_with_auth(&env, &non_owner, &oapp_client, &enforced_params);
 }
@@ -195,7 +195,7 @@ fn test_set_enforced_options_invalid_options_returns_error() {
     invalid.extend_from_slice(&[1, 2, 3]);
 
     let enforced_params =
-        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: invalid }];
+        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(invalid) }];
 
     env.mock_auths(&[MockAuth {
         address: &owner,
@@ -215,7 +215,7 @@ fn test_combine_options_extra_invalid_type_returns_error_when_enforced_present()
     let TestSetup { env, owner, oapp_client, .. } = setup();
 
     let enforced = create_valid_options(&env, &[1, 2, 3]);
-    let params = vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced }];
+    let params = vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(enforced) }];
     set_enforced_options_with_auth(&env, &owner, &oapp_client, &params);
 
     // extra has wrong option type (not 3) but len >= 2 -> validated and should panic
@@ -230,7 +230,7 @@ fn test_combine_options_extra_too_short_returns_error_when_enforced_present() {
     let TestSetup { env, owner, oapp_client, .. } = setup();
 
     let enforced = create_valid_options(&env, &[1, 2, 3]);
-    let params = vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced }];
+    let params = vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: Some(enforced) }];
     set_enforced_options_with_auth(&env, &owner, &oapp_client, &params);
 
     // extra is non-empty but len < 2 -> should panic

package/contracts/oapps/oapp/src/tests/oapp_receiver.rs

@@ -27,7 +27,7 @@ impl LzReceiveInternal for DummyOAppReceiver {
 #[contractimpl]
 impl DummyOAppReceiver {
     pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
-        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, &None);
+        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, owner);
     }
 }
 
@@ -355,7 +355,7 @@ fn test_lz_receive_wrong_peer_returns_only_peer_error() {
 }
 
 #[test]
-fn test_lz_receive_no_peer_returns_only_peer_error() {
+fn test_lz_receive_no_peer_returns_no_peer_error() {
     let TestSetup { env, oapp_client, .. } = setup();
 
     let executor = Address::generate(&env);
@@ -375,7 +375,7 @@ fn test_lz_receive_no_peer_returns_only_peer_error() {
         },
     }]);
 
-    // No peer configured -> should fail the peer check with OnlyPeer
+    // No peer configured -> should fail with NoPeer since no peer is set for the source eid
     let result = oapp_client.try_lz_receive(&executor, &origin, &guid, &message, &extra_data, &value);
-    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::OnlyPeer.into());
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::NoPeer.into());
 }

package/contracts/oapps/oapp/src/tests/oapp_sender.rs

@@ -1,4 +1,4 @@
-use crate::{self as oapp, errors::OAppError, oapp_receiver::LzReceiveInternal};
+use crate::{self as oapp, errors::OAppError, oapp_receiver::LzReceiveInternal, oapp_sender::FeePayer};
 use endpoint_v2::{MessagingFee, MessagingParams, MessagingReceipt, Origin};
 use soroban_sdk::{
     contract, contractimpl, symbol_short,
@@ -83,7 +83,7 @@ impl LzReceiveInternal for DummyOAppSender {
 #[contractimpl]
 impl DummyOAppSender {
     pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
-        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, &None);
+        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, owner);
     }
 
     pub fn quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
@@ -100,7 +100,7 @@ impl DummyOAppSender {
         refund_address: &Address,
     ) -> MessagingReceipt {
         sender.require_auth();
-        Self::__lz_send(env, dst_eid, message, options, sender, fee, refund_address)
+        Self::__lz_send(env, dst_eid, message, options, &FeePayer::Verified(sender.clone()), fee, refund_address)
     }
 
     pub fn pay_native_fee(env: &Env, fee_payer: &Address, native_fee: i128) {

package/contracts/oapps/oapp-macros/Cargo.toml

@@ -9,7 +9,6 @@ publish = false
 proc-macro = true
 
 [dependencies]
-heck = { workspace = true }
 proc-macro2 = { workspace = true }
 quote = { workspace = true }
 syn = { workspace = true }

package/contracts/oapps/oapp-macros/src/generators.rs

@@ -1,9 +1,69 @@
 //! Code generators for OApp trait implementations.
 
-use crate::CustomImpls;
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{Ident, ItemStruct};
+use syn::{
+    bracketed,
+    parse::{Parse, ParseStream},
+    punctuated::Punctuated,
+    Error, Ident, ItemStruct, Token,
+};
+
+/// Specifies which OApp trait implementations the user will provide themselves.
+///
+/// Parsed from `#[oapp(custom = [...])]`. When a field is `true`, the macro skips
+/// generating that trait implementation, allowing the user to provide their own.
+#[derive(Debug, Clone, Copy, Default)]
+pub(crate) struct CustomImpls {
+    pub core: bool,
+    pub sender: bool,
+    pub receiver: bool,
+    pub options_type3: bool,
+}
+
+impl Parse for CustomImpls {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        if input.is_empty() {
+            return Ok(Self::default());
+        }
+
+        // Consume the `custom` keyword
+        let key: Ident = input.parse()?;
+        if key != "custom" {
+            return Err(Error::new(key.span(), "expected `custom`"));
+        }
+
+        // Consume the `=` in `custom = [...]`
+        input.parse::<Token![=]>()?;
+
+        // Parse the `[...]` brackets and capture the inner tokens into `content`
+        let content;
+        bracketed!(content in input);
+
+        // Parse the comma-separated list of identifiers into `idents`
+        let idents = Punctuated::<Ident, Token![,]>::parse_terminated(&content)?;
+
+        // Initialize the custom implementations struct
+        let mut custom_impls = Self::default();
+
+        for ident in idents {
+            match ident.to_string().as_str() {
+                "core" => custom_impls.core = true,
+                "sender" => custom_impls.sender = true,
+                "receiver" => custom_impls.receiver = true,
+                "options_type3" => custom_impls.options_type3 = true,
+                _ => {
+                    return Err(Error::new(
+                        ident.span(),
+                        "expected one of `core`, `sender`, `receiver`, `options_type3`",
+                    ));
+                }
+            }
+        }
+
+        Ok(custom_impls)
+    }
+}
 
 /// Generates a complete OApp implementation with contract attributes and trait implementations.
 ///
@@ -17,14 +77,17 @@ use syn::{Ident, ItemStruct};
 ///
 /// The `custom` parameter controls which trait implementations are generated vs.
 /// expected to be provided by the user.
-pub fn generate_oapp(item: ItemStruct, custom: CustomImpls) -> TokenStream {
-    let core_impl = generate_oapp_core(&item.ident, custom.core);
-    let sender_impl = generate_oapp_sender(&item.ident, custom.sender);
-    let receiver_impl = generate_oapp_receiver(&item.ident, custom.receiver);
-    let options_type3_impl = generate_oapp_options_type3(&item.ident, custom.options_type3);
+pub fn generate_oapp(attr: TokenStream, input: TokenStream) -> TokenStream {
+    let custom: CustomImpls = syn::parse2(attr).unwrap_or_else(|e| panic!("failed to parse oapp attributes: {}", e));
+    let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
+
+    let core_impl = (!custom.core).then(|| generate_oapp_core(&item_struct.ident));
+    let sender_impl = (!custom.sender).then(|| generate_oapp_sender(&item_struct.ident));
+    let receiver_impl = (!custom.receiver).then(|| generate_oapp_receiver(&item_struct.ident));
+    let options_type3_impl = (!custom.options_type3).then(|| generate_oapp_options_type3(&item_struct.ident));
     quote! {
         #[common_macros::lz_contract]
-        #item
+        #item_struct
 
         #core_impl
         #sender_impl
@@ -33,15 +96,9 @@ pub fn generate_oapp(item: ItemStruct, custom: CustomImpls) -> TokenStream {
     }
 }
 
-/// Generates the `OAppCore` trait implementation.
-///
-/// When `custom` is false, generates an empty `impl OAppCore` that uses the trait's
-/// default implementations for peer management and endpoint access.
-fn generate_oapp_core(name: &Ident, custom: bool) -> TokenStream {
-    if custom {
-        return TokenStream::new();
-    }
-
+/// Generates an empty `impl OAppCore` that uses the trait's default implementations
+/// for peer management and endpoint access.
+fn generate_oapp_core(name: &Ident) -> TokenStream {
     quote! {
         use oapp::oapp_core::OAppCore as _;
 
@@ -52,31 +109,21 @@ fn generate_oapp_core(name: &Ident, custom: bool) -> TokenStream {
 
 /// Generates the `OAppSenderInternal` trait implementation.
 ///
-/// When `custom` is false, generates an empty `impl OAppSenderInternal` that uses the
-/// trait's default implementations for `__lz_quote` and `__lz_send`.
-fn generate_oapp_sender(name: &Ident, custom: bool) -> TokenStream {
-    if custom {
-        TokenStream::new()
-    } else {
-        quote! {
-            use oapp::oapp_sender::OAppSenderInternal as _;
-
-            impl oapp::oapp_sender::OAppSenderInternal for #name {}
-        }
+/// Generates an empty `impl OAppSenderInternal` that uses the trait's default
+/// implementations for `__lz_quote` and `__lz_send`.
+fn generate_oapp_sender(name: &Ident) -> TokenStream {
+    quote! {
+        use oapp::oapp_sender::OAppSenderInternal as _;
+
+        impl oapp::oapp_sender::OAppSenderInternal for #name {}
     }
 }
 
-/// Generates the `OAppReceiver` trait implementation.
-///
-/// When `custom` is false, generates an empty `impl OAppReceiver` that uses the trait's default
-/// `lz_receive` implementation (which calls `clear_payload_and_transfer` then `__lz_receive`).
+/// Generates an empty `impl OAppReceiver` that uses the trait's default `lz_receive`
+/// implementation (which calls `clear_payload_and_transfer` then `__lz_receive`).
 ///
 /// Users must implement `LzReceiveInternal` themselves to provide the `__lz_receive` method.
-fn generate_oapp_receiver(name: &Ident, custom: bool) -> TokenStream {
-    if custom {
-        return TokenStream::new();
-    }
-
+fn generate_oapp_receiver(name: &Ident) -> TokenStream {
     quote! {
         use oapp::oapp_receiver::OAppReceiver as _;
 
@@ -85,15 +132,9 @@ fn generate_oapp_receiver(name: &Ident, custom: bool) -> TokenStream {
     }
 }
 
-/// Generates the `OAppOptionsType3` trait implementation.
-///
-/// When `custom` is false, generates an empty `impl OAppOptionsType3` that uses the
-/// trait's default implementations for enforced options management.
-fn generate_oapp_options_type3(name: &Ident, custom: bool) -> TokenStream {
-    if custom {
-        return TokenStream::new();
-    }
-
+/// Generates an empty `impl OAppOptionsType3` that uses the trait's default
+/// implementations for enforced options management.
+fn generate_oapp_options_type3(name: &Ident) -> TokenStream {
     quote! {
         use oapp::oapp_options_type3::OAppOptionsType3 as _;
 

package/contracts/oapps/oapp-macros/src/lib.rs

@@ -125,15 +125,6 @@
 mod generators;
 
 use proc_macro::TokenStream;
-use syn::{
-    bracketed,
-    parse::{Parse, ParseStream},
-    punctuated::Punctuated,
-    Error, Ident, ItemStruct, Token,
-};
-
-#[cfg(test)]
-mod tests;
 
 /// Derives a complete OApp: `#[contract]` + `#[ownable]` + Core + Sender + Receiver + OptionsType3.
 ///
@@ -158,57 +149,8 @@ mod tests;
 /// You must implement `LzReceiveInternal` for your struct. See module docs for examples.
 #[proc_macro_attribute]
 pub fn oapp(attr: TokenStream, item: TokenStream) -> TokenStream {
-    let custom = syn::parse_macro_input!(attr as CustomImpls);
-    let item_struct = syn::parse_macro_input!(item as ItemStruct);
-    generators::generate_oapp(item_struct, custom).into()
-}
-
-/// Specifies which OApp trait implementations the user will provide themselves.
-///
-/// Parsed from `#[oapp(custom = [...])]`. When a field is `true`, the macro skips
-/// generating that trait implementation, allowing the user to provide their own.
-#[derive(Debug, Clone, Copy, Default)]
-struct CustomImpls {
-    pub core: bool,
-    pub sender: bool,
-    pub receiver: bool,
-    pub options_type3: bool,
+    generators::generate_oapp(attr.into(), item.into()).into()
 }
 
-impl Parse for CustomImpls {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        if input.is_empty() {
-            return Ok(Self::default());
-        }
-
-        let key: Ident = input.parse()?;
-        if key != "custom" {
-            return Err(Error::new(key.span(), "expected `custom`"));
-        }
-
-        input.parse::<Token![=]>()?;
-
-        let content;
-        bracketed!(content in input);
-
-        let idents = Punctuated::<Ident, Token![,]>::parse_terminated(&content)?;
-        let mut custom_impls = Self::default();
-
-        for ident in idents {
-            match ident.to_string().as_str() {
-                "core" => custom_impls.core = true,
-                "sender" => custom_impls.sender = true,
-                "receiver" => custom_impls.receiver = true,
-                "options_type3" => custom_impls.options_type3 = true,
-                _ => {
-                    return Err(Error::new(
-                        ident.span(),
-                        "expected one of `core`, `sender`, `receiver`, `options_type3`",
-                    ));
-                }
-            }
-        }
-
-        Ok(custom_impls)
-    }
-}
+#[cfg(test)]
+mod tests;

package/contracts/oapps/oapp-macros/src/tests/oapp.rs

@@ -6,52 +6,39 @@ use quote::quote;
 
 #[test]
 fn snapshot_generate_oapp() {
-    let input = quote! {
+    let struct_input = quote! {
         pub struct MyOApp;
     };
-    let item_struct: syn::ItemStruct = syn::parse2(input).expect("failed to parse struct");
 
     let all_defaults = {
-        let result = crate::generators::generate_oapp(item_struct.clone(), crate::CustomImpls::default());
+        let result = crate::generators::generate_oapp(quote! {}, struct_input.clone());
         prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"))
     };
 
     let custom_core_only = {
-        let result = crate::generators::generate_oapp(
-            item_struct.clone(),
-            crate::CustomImpls { core: true, sender: false, receiver: false, options_type3: false },
-        );
+        let result = crate::generators::generate_oapp(quote! { custom = [core] }, struct_input.clone());
         prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"))
     };
 
     let custom_sender_only = {
-        let result = crate::generators::generate_oapp(
-            item_struct.clone(),
-            crate::CustomImpls { core: false, sender: true, receiver: false, options_type3: false },
-        );
+        let result = crate::generators::generate_oapp(quote! { custom = [sender] }, struct_input.clone());
         prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"))
     };
 
     let custom_receiver_only = {
-        let result = crate::generators::generate_oapp(
-            item_struct.clone(),
-            crate::CustomImpls { core: false, sender: false, receiver: true, options_type3: false },
-        );
+        let result = crate::generators::generate_oapp(quote! { custom = [receiver] }, struct_input.clone());
         prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"))
     };
 
     let custom_options_type3_only = {
-        let result = crate::generators::generate_oapp(
-            item_struct.clone(),
-            crate::CustomImpls { core: false, sender: false, receiver: false, options_type3: true },
-        );
+        let result = crate::generators::generate_oapp(quote! { custom = [options_type3] }, struct_input.clone());
         prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"))
     };
 
     let custom_all = {
         let result = crate::generators::generate_oapp(
-            item_struct.clone(),
-            crate::CustomImpls { core: true, sender: true, receiver: true, options_type3: true },
+            quote! { custom = [core, sender, receiver, options_type3] },
+            struct_input.clone(),
         );
         prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"))
     };
@@ -63,8 +50,7 @@ fn snapshot_generate_oapp() {
                 pub x: u32,
             }
         };
-        let fancy_struct: syn::ItemStruct = syn::parse2(fancy_input).expect("failed to parse struct");
-        let result = crate::generators::generate_oapp(fancy_struct, crate::CustomImpls::default());
+        let result = crate::generators::generate_oapp(quote! {}, fancy_input);
         prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"))
     };