@layerzerolabs/oapp-macros-stellar-contracts 0.2.122

package/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "oapp-macros"
+version = "0.0.1"
+edition = "2021"
+publish = false
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full", "extra-traits"] }
+
+[dev-dependencies]
+insta = "1.44.3"
+prettyplease = "0.2.37"

package/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2026 - LayerZero Labs Ltd.
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/clippy.toml

@@ -0,0 +1,6 @@
+# Clippy configuration for Stellar contracts
+
+# Set the too_many_arguments threshold to 11.
+# This aligns with Stellar: contract functions are limited to 10 parameters, plus 1 for 'env'.
+# (Default is 7; raised here to prevent unnecessary clippy warnings on valid contract interfaces.)
+too-many-arguments-threshold = 11

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@layerzerolabs/oapp-macros-stellar-contracts",
+  "version": "0.2.122",
+  "private": false,
+  "description": "Stellar OApp procedural macros",
+  "license": "MIT",
+  "files": [
+    "LICENSE",
+    "src",
+    "Cargo.toml",
+    "rust-toolchain.toml",
+    "rustfmt.toml",
+    "clippy.toml"
+  ],
+  "devDependencies": {
+    "@layerzerolabs/vm-tooling-stellar": "0.2.122"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "externalRepoConfig": {
+    "targets": [
+      "audit-external",
+      "console-pen-test",
+      "monorepo-external",
+      "onesig-client"
+    ]
+  },
+  "scripts": {
+    "build": "pnpm exec lz-tool --script \"cargo build\" stellar",
+    "clean": "rm -rf ./target ./node_modules",
+    "format": "pnpm exec lz-tool --script \"cargo fmt\" stellar",
+    "lint": "pnpm exec lz-tool --script \"cargo clippy -- -D warnings\" stellar",
+    "test": "pnpm exec lz-tool --script \"cargo nextest run\" stellar"
+  }
+}

package/rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "1.90.0"
+targets = ["wasm32v1-none"]
+components = ["rustfmt", "clippy"]

package/rustfmt.toml

@@ -0,0 +1,15 @@
+format_macro_bodies = true
+max_width = 120
+format_macro_matchers = true
+format_strings = true
+imports_granularity = "Crate"
+match_arm_blocks = false
+reorder_impl_items = true
+group_imports = "StdExternalCrate"
+use_field_init_shorthand = true
+use_small_heuristics = "Max"
+wrap_comments = true
+format_code_in_doc_comments = true
+
+# most of these are unstable, so we enable them
+unstable_features = true

package/src/generators.rs

@@ -0,0 +1,147 @@
+//! Code generators for OApp trait implementations.
+
+use proc_macro2::TokenStream;
+use quote::quote;
+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 OApp trait implementations only. No contract-level attributes are applied.
+///
+/// This function creates OAppCore, OAppSenderInternal, OAppReceiver, and OAppOptionsType3 trait implementations.
+///
+/// **The user must apply a contract macro** such as `#[common_macros::lz_contract]` or
+/// `#[soroban_sdk::contract]` to the struct. `#[lz_contract]` provides contract, TTL, and Auth
+/// (via `#[ownable]` or `#[multisig]`) in one place.
+///
+/// The `custom` parameter controls which trait implementations are generated vs.
+/// expected to be provided by the user.
+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! {
+        #item_struct
+
+        #core_impl
+        #sender_impl
+        #receiver_impl
+        #options_type3_impl
+    }
+}
+
+/// Generates an empty `impl OAppCore` that uses the trait's default implementations
+/// for peer management and endpoint access.
+///
+/// Also generates `impl RoleBasedAccessControl` because OAppCore extends it.
+fn generate_oapp_core(name: &Ident) -> TokenStream {
+    quote! {
+        use oapp::oapp_core::OAppCore as _;
+        use utils::rbac::RoleBasedAccessControl as _;
+
+        #[soroban_sdk::contractimpl(contracttrait)]
+        impl oapp::oapp_core::OAppCore for #name {}
+
+        #[soroban_sdk::contractimpl(contracttrait)]
+        impl utils::rbac::RoleBasedAccessControl for #name {}
+    }
+}
+
+/// Generates the `OAppSenderInternal` trait implementation.
+///
+/// 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 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) -> TokenStream {
+    quote! {
+        use oapp::oapp_receiver::OAppReceiver as _;
+
+        #[soroban_sdk::contractimpl(contracttrait)]
+        impl oapp::oapp_receiver::OAppReceiver for #name {}
+    }
+}
+
+/// 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 _;
+
+        #[soroban_sdk::contractimpl(contracttrait)]
+        impl oapp::oapp_options_type3::OAppOptionsType3 for #name {}
+    }
+}

package/src/lib.rs

@@ -0,0 +1,166 @@
+//! # OApp Procedural Macros
+//!
+//! This crate provides the `#[oapp]` procedural macro for implementing LayerZero OApp
+//! (Omnichain Application) functionality on Soroban smart contracts.
+//!
+//! ## Overview
+//!
+//! The OApp framework provides full bidirectional cross-chain communication:
+//!
+//! - **OAppCore**: Foundation for all OApp functionality (peer management, endpoint access)
+//! - **OAppSenderInternal**: Enables sending cross-chain messages through LayerZero
+//! - **LzReceiveInternal**: Internal trait for message handling logic
+//! - **OAppReceiver**: Handles incoming cross-chain messages (has default `lz_receive` impl)
+//! - **OAppOptionsType3**: Manages enforced options for message execution parameters
+//!
+//! ## Usage
+//!
+//! ### `#[oapp]`
+//! The main macro that provides Core + Sender + Receiver + OptionsType3 functionality.
+//! This is the only macro you need for cross-chain communication.
+//!
+//! ### Custom Implementations
+//!
+//! By default, `#[oapp]` generates default trait implementations. Use `#[oapp(custom = [...])]`
+//! to provide your own custom implementations for specific traits:
+//!
+//! Supported options:
+//! - `core` - Custom implement `OAppCore`
+//! - `sender` - Custom implement `OAppSenderInternal`
+//! - `receiver` - Custom implement `OAppReceiver` (useful for custom `next_nonce`, etc.)
+//! - `options_type3` - Custom implement `OAppOptionsType3`
+//!
+//! ## Examples
+//!
+//! ### Full OApp with Default Implementations
+//!
+//! ```ignore
+//! use oapp::oapp_receiver::LzReceiveInternal;
+//! use oapp_macros::oapp;
+//!
+//! #[oapp]
+//! #[common_macros::lz_contract]
+//! struct MyOApp;
+//!
+//! // Implement LzReceiveInternal to handle incoming messages
+//! impl LzReceiveInternal for MyOApp {
+//!     fn __lz_receive(
+//!         env: &Env,
+//!         origin: &Origin,
+//!         guid: &BytesN<32>,
+//!         message: &Bytes,
+//!         extra_data: &Bytes,
+//!         executor: &Address,
+//!         value: i128,
+//!     ) {
+//!         // Your message handling logic (clear_payload_and_transfer already called)
+//!     }
+//! }
+//! ```
+//!
+//! ### OApp with Custom Core Version
+//!
+//! ```ignore
+//! use oapp::oapp_receiver::LzReceiveInternal;
+//! use utils::rbac::RoleBasedAccessControl;
+//!
+//! #[oapp(custom = [core])]
+//! #[common_macros::lz_contract]
+//! struct MyOApp;
+//!
+//! // Required: `custom = [core]` skips generating both OAppCore and RoleBasedAccessControl impls
+//! impl RoleBasedAccessControl for MyOApp {}
+//!
+//! #[contractimpl(contracttrait)]
+//! impl OAppCore for MyOApp {
+//!     fn oapp_version(_env: &Env) -> (u64, u64) {
+//!         (1, 1) // Custom version
+//!     }
+//! }
+//!
+//! impl LzReceiveInternal for MyOApp {
+//!     fn __lz_receive(...) { /* ... */ }
+//! }
+//! ```
+//!
+//! ### OApp with Custom Receiver (e.g., ordered delivery)
+//!
+//! ```ignore
+//! use oapp::oapp_receiver::{LzReceiveInternal, OAppReceiver};
+//!
+//! #[oapp(custom = [receiver])]
+//! #[common_macros::lz_contract]
+//! struct MyOrderedOApp;
+//!
+//! impl LzReceiveInternal for MyOrderedOApp {
+//!     fn __lz_receive(env: &Env, origin: &Origin, guid: &BytesN<32>, ...) {
+//!         // Your message handling logic
+//!     }
+//! }
+//!
+//! #[contractimpl(contracttrait)]
+//! impl OAppReceiver for MyOrderedOApp {
+//!     fn next_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>) -> u64 {
+//!         // Custom nonce logic for ordered delivery
+//!         Storage::max_received_nonce(env, src_eid, sender) + 1
+//!     }
+//!     // lz_receive uses default impl which calls clear_payload_and_transfer then __lz_receive
+//! }
+//! ```
+//!
+//! ### OApp with Multiple Custom Implementations
+//!
+//! ```ignore
+//! use oapp::oapp_receiver::LzReceiveInternal;
+//! use utils::rbac::RoleBasedAccessControl;
+//!
+//! #[oapp(custom = [core, sender, options_type3])]
+//! #[common_macros::lz_contract]
+//! struct MyCustomOApp;
+//!
+//! // Required: `custom = [core]` skips generating both OAppCore and RoleBasedAccessControl impls
+//! impl RoleBasedAccessControl for MyCustomOApp {}
+//!
+//! #[contractimpl(contracttrait)]
+//! impl OAppCore for MyCustomOApp { /* ... */ }
+//! impl OAppSenderInternal for MyCustomOApp { /* ... */ }
+//! #[contractimpl(contracttrait)]
+//! impl OAppOptionsType3 for MyCustomOApp { /* ... */ }
+//!
+//! impl LzReceiveInternal for MyCustomOApp {
+//!     fn __lz_receive(...) { /* ... */ }
+//! }
+//! ```
+
+mod generators;
+
+use proc_macro::TokenStream;
+
+/// Derives OApp trait implementations. Apply `#[lz_contract]` (or similar) for contract + TTL + Auth.
+///
+/// ## Usage
+///
+/// ```ignore
+/// // Default: generates all trait implementations
+/// #[oapp]
+/// struct MyOApp;
+///
+/// // Provide custom implementations for specific traits
+/// #[oapp(custom = [core, receiver])]
+/// struct MyCustomOApp;
+/// ```
+///
+/// ## Custom Options
+/// - `core` - Manually implement `OAppCore`
+/// - `sender` - Manually implement `OAppSenderInternal`
+/// - `receiver` - Manually implement `OAppReceiver`
+/// - `options_type3` - Manually implement `OAppOptionsType3`
+///
+/// You must implement `LzReceiveInternal` for your struct. See module docs for examples.
+#[proc_macro_attribute]
+pub fn oapp(attr: TokenStream, item: TokenStream) -> TokenStream {
+    generators::generate_oapp(attr.into(), item.into()).into()
+}
+
+#[cfg(test)]
+mod tests;

package/src/tests/mod.rs

@@ -0,0 +1,2 @@
+mod oapp;
+mod parse_custom_impls;

package/src/tests/oapp.rs

@@ -0,0 +1,74 @@
+use quote::quote;
+
+// ============================================
+// Snapshot Tests: OApp Code Generation
+// ============================================
+
+#[test]
+fn snapshot_generate_oapp() {
+    let struct_input = quote! {
+        pub struct MyOApp;
+    };
+
+    let all_defaults = {
+        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(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(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(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(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(
+            quote! { custom = [core, sender, receiver, options_type3] },
+            struct_input.clone(),
+        );
+        prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"))
+    };
+
+    let preserves_struct_attributes_and_fields = {
+        let fancy_input = quote! {
+            #[derive(Clone, Debug)]
+            pub struct FancyOApp {
+                pub x: u32,
+            }
+        };
+        let result = crate::generators::generate_oapp(quote! {}, fancy_input);
+        prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"))
+    };
+
+    let combined = format!(
+        "// === Default (no custom impls) ===\n\n{}\n\n\
+// === custom = [core] ===\n\n{}\n\n\
+// === custom = [sender] ===\n\n{}\n\n\
+// === custom = [receiver] ===\n\n{}\n\n\
+// === custom = [options_type3] ===\n\n{}\n\n\
+// === custom = [core, sender, receiver, options_type3] ===\n\n{}\n\n\
+// === Struct attributes + fields are preserved ===\n\n{}",
+        all_defaults,
+        custom_core_only,
+        custom_sender_only,
+        custom_receiver_only,
+        custom_options_type3_only,
+        custom_all,
+        preserves_struct_attributes_and_fields
+    );
+    insta::assert_snapshot!(combined);
+}

package/src/tests/parse_custom_impls.rs

@@ -0,0 +1,90 @@
+use quote::quote;
+
+// ============================================
+// Unit Tests: #[oapp(custom = [...])] parsing
+// ============================================
+
+#[test]
+fn test_custom_impls_parse_empty_is_default() {
+    let parsed: crate::generators::CustomImpls = syn::parse2(quote! {}).expect("failed to parse empty attrs");
+    assert!(!parsed.core);
+    assert!(!parsed.sender);
+    assert!(!parsed.receiver);
+    assert!(!parsed.options_type3);
+}
+
+#[test]
+fn test_custom_impls_parse_valid_all_list() {
+    let parsed: crate::generators::CustomImpls =
+        syn::parse2(quote! { custom = [core, sender, receiver, options_type3] }).expect("failed to parse attrs");
+    assert!(parsed.core);
+    assert!(parsed.sender);
+    assert!(parsed.receiver);
+    assert!(parsed.options_type3);
+}
+
+#[test]
+fn test_custom_impls_parse_empty_custom_list_is_default() {
+    let parsed: crate::generators::CustomImpls = syn::parse2(quote! { custom = [] }).expect("failed to parse attrs");
+    assert!(!parsed.core);
+    assert!(!parsed.sender);
+    assert!(!parsed.receiver);
+    assert!(!parsed.options_type3);
+}
+
+#[test]
+fn test_custom_impls_allows_trailing_comma() {
+    let parsed: crate::generators::CustomImpls =
+        syn::parse2(quote! { custom = [core,] }).expect("failed to parse attrs");
+    assert!(parsed.core);
+    assert!(!parsed.sender);
+    assert!(!parsed.receiver);
+    assert!(!parsed.options_type3);
+}
+
+#[test]
+fn test_custom_impls_allows_duplicates() {
+    // Duplicates are harmless and should not cause parsing to fail.
+    let parsed: crate::generators::CustomImpls =
+        syn::parse2(quote! { custom = [core, core, receiver, receiver] }).expect("failed to parse attrs");
+    assert!(parsed.core);
+    assert!(!parsed.sender);
+    assert!(parsed.receiver);
+    assert!(!parsed.options_type3);
+}
+
+#[test]
+fn test_custom_impls_rejects_wrong_key() {
+    let err =
+        syn::parse2::<crate::generators::CustomImpls>(quote! { nope = [core] }).expect_err("expected parse failure");
+    assert!(err.to_string().contains("expected `custom`"), "unexpected error: {err}");
+}
+
+#[test]
+fn test_custom_impls_rejects_unknown_ident() {
+    let err = syn::parse2::<crate::generators::CustomImpls>(quote! { custom = [core, not_a_real_option] })
+        .expect_err("expected failure");
+    assert!(
+        err.to_string().contains("expected one of `core`, `sender`, `receiver`, `options_type3`"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn test_custom_impls_rejects_trailing_tokens_after_list() {
+    // `syn::parse2` expects the parser to consume the full stream.
+    syn::parse2::<crate::generators::CustomImpls>(quote! { custom = [core] extra })
+        .expect_err("expected parse failure due to trailing tokens");
+}
+
+#[test]
+fn test_custom_impls_rejects_missing_equals() {
+    syn::parse2::<crate::generators::CustomImpls>(quote! { custom [core] })
+        .expect_err("expected parse failure (missing `=`)");
+}
+
+#[test]
+fn test_custom_impls_rejects_non_bracketed_list() {
+    syn::parse2::<crate::generators::CustomImpls>(quote! { custom = (core) })
+        .expect_err("expected parse failure (not `[...]`)");
+}

package/src/tests/snapshots/oapp_macros__tests__oapp__snapshot_generate_oapp.snap

@@ -0,0 +1,111 @@
+---
+source: contracts/oapps/oapp-macros/src/tests/oapp.rs
+assertion_line: 87
+expression: combined
+---
+// === Default (no custom impls) ===
+
+pub struct MyOApp;
+use oapp::oapp_core::OAppCore as _;
+use utils::rbac::RoleBasedAccessControl as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_core::OAppCore for MyOApp {}
+#[soroban_sdk::contractimpl(contracttrait)]
+impl utils::rbac::RoleBasedAccessControl for MyOApp {}
+use oapp::oapp_sender::OAppSenderInternal as _;
+impl oapp::oapp_sender::OAppSenderInternal for MyOApp {}
+use oapp::oapp_receiver::OAppReceiver as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_receiver::OAppReceiver for MyOApp {}
+use oapp::oapp_options_type3::OAppOptionsType3 as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_options_type3::OAppOptionsType3 for MyOApp {}
+
+
+// === custom = [core] ===
+
+pub struct MyOApp;
+use oapp::oapp_sender::OAppSenderInternal as _;
+impl oapp::oapp_sender::OAppSenderInternal for MyOApp {}
+use oapp::oapp_receiver::OAppReceiver as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_receiver::OAppReceiver for MyOApp {}
+use oapp::oapp_options_type3::OAppOptionsType3 as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_options_type3::OAppOptionsType3 for MyOApp {}
+
+
+// === custom = [sender] ===
+
+pub struct MyOApp;
+use oapp::oapp_core::OAppCore as _;
+use utils::rbac::RoleBasedAccessControl as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_core::OAppCore for MyOApp {}
+#[soroban_sdk::contractimpl(contracttrait)]
+impl utils::rbac::RoleBasedAccessControl for MyOApp {}
+use oapp::oapp_receiver::OAppReceiver as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_receiver::OAppReceiver for MyOApp {}
+use oapp::oapp_options_type3::OAppOptionsType3 as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_options_type3::OAppOptionsType3 for MyOApp {}
+
+
+// === custom = [receiver] ===
+
+pub struct MyOApp;
+use oapp::oapp_core::OAppCore as _;
+use utils::rbac::RoleBasedAccessControl as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_core::OAppCore for MyOApp {}
+#[soroban_sdk::contractimpl(contracttrait)]
+impl utils::rbac::RoleBasedAccessControl for MyOApp {}
+use oapp::oapp_sender::OAppSenderInternal as _;
+impl oapp::oapp_sender::OAppSenderInternal for MyOApp {}
+use oapp::oapp_options_type3::OAppOptionsType3 as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_options_type3::OAppOptionsType3 for MyOApp {}
+
+
+// === custom = [options_type3] ===
+
+pub struct MyOApp;
+use oapp::oapp_core::OAppCore as _;
+use utils::rbac::RoleBasedAccessControl as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_core::OAppCore for MyOApp {}
+#[soroban_sdk::contractimpl(contracttrait)]
+impl utils::rbac::RoleBasedAccessControl for MyOApp {}
+use oapp::oapp_sender::OAppSenderInternal as _;
+impl oapp::oapp_sender::OAppSenderInternal for MyOApp {}
+use oapp::oapp_receiver::OAppReceiver as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_receiver::OAppReceiver for MyOApp {}
+
+
+// === custom = [core, sender, receiver, options_type3] ===
+
+pub struct MyOApp;
+
+
+// === Struct attributes + fields are preserved ===
+
+#[derive(Clone, Debug)]
+pub struct FancyOApp {
+    pub x: u32,
+}
+use oapp::oapp_core::OAppCore as _;
+use utils::rbac::RoleBasedAccessControl as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_core::OAppCore for FancyOApp {}
+#[soroban_sdk::contractimpl(contracttrait)]
+impl utils::rbac::RoleBasedAccessControl for FancyOApp {}
+use oapp::oapp_sender::OAppSenderInternal as _;
+impl oapp::oapp_sender::OAppSenderInternal for FancyOApp {}
+use oapp::oapp_receiver::OAppReceiver as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_receiver::OAppReceiver for FancyOApp {}
+use oapp::oapp_options_type3::OAppOptionsType3 as _;
+#[soroban_sdk::contractimpl(contracttrait)]
+impl oapp::oapp_options_type3::OAppOptionsType3 for FancyOApp {}