@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/message-libs/message-lib-common/src/tests/worker_options.rs

@@ -1,319 +0,0 @@
-use crate::worker_options::{
-    convert_legacy_options, split_worker_options, EXECUTOR_OPTION_TYPE_LZRECEIVE, EXECUTOR_OPTION_TYPE_NATIVE_DROP,
-    EXECUTOR_WORKER_ID, LEGACY_OPTIONS_TYPE_1, LEGACY_OPTIONS_TYPE_2, OPTIONS_TYPE_3,
-};
-use hex_literal::hex;
-use soroban_sdk::{Bytes, BytesN, Env};
-use utils::buffer_reader::BufferReader;
-
-#[test]
-fn test_split_worker_options_dvn_only() {
-    let env = Env::default();
-
-    // Build TYPE_3 options with only DVN options
-    // x"0003" + x"020002000102000302ff0102000200010200020101"
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
-    options.extend_from_slice(&hex!("020002000102000302ff0102000200010200020101"));
-
-    let (executor_options, dvn_options) = split_worker_options(&env, &options);
-
-    assert_eq!(executor_options.len(), 0);
-    assert_eq!(dvn_options.len(), 3);
-
-    // Check DVN options are grouped correctly by index
-    assert_eq!(dvn_options.get(0).unwrap(), Bytes::from_slice(&env, &hex!("02000200010200020001")));
-    assert_eq!(dvn_options.get(1).unwrap(), Bytes::from_slice(&env, &hex!("0200020101")));
-    assert_eq!(dvn_options.get(2).unwrap(), Bytes::from_slice(&env, &hex!("02000302ff01")));
-}
-
-#[test]
-fn test_split_worker_options_executor_only() {
-    let env = Env::default();
-
-    // Build TYPE_3 options with two executor options
-    // x"0003" + x"0100110100000000000000000000000000009470010011010000000000000000000000000000ea60"
-    let executor_options_raw = hex!("0100110100000000000000000000000000009470010011010000000000000000000000000000ea60");
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
-    options.extend_from_slice(&executor_options_raw);
-
-    let (executor_options, dvn_options) = split_worker_options(&env, &options);
-
-    assert_eq!(executor_options, Bytes::from_slice(&env, &executor_options_raw));
-    assert_eq!(dvn_options.len(), 0);
-}
-
-#[test]
-fn test_split_worker_options_options() {
-    let env = Env::default();
-
-    // Build TYPE_3 options with executor and DVN options
-    // executor: x"0100110100000000000000000000000000009470010011010000000000000000000000000000ea60"
-    // dvn: x"020002000102000302ff0102000200010200020101"
-    let executor_options_raw = hex!("0100110100000000000000000000000000009470010011010000000000000000000000000000ea60");
-    let dvn_options_raw = hex!("020002000102000302ff0102000200010200020101");
-
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
-    options.extend_from_slice(&executor_options_raw);
-    options.extend_from_slice(&dvn_options_raw);
-
-    let (executor_options, dvn_options) = split_worker_options(&env, &options);
-
-    assert_eq!(executor_options, Bytes::from_slice(&env, &executor_options_raw));
-    assert_eq!(dvn_options.len(), 3);
-
-    // Check DVN options grouped by index
-    assert_eq!(dvn_options.get(0).unwrap(), Bytes::from_slice(&env, &hex!("02000200010200020001")));
-    assert_eq!(dvn_options.get(1).unwrap(), Bytes::from_slice(&env, &hex!("0200020101")));
-    assert_eq!(dvn_options.get(2).unwrap(), Bytes::from_slice(&env, &hex!("02000302ff01")));
-}
-
-#[test]
-fn test_decode_legacy_options_type_1() {
-    let env = Env::default();
-
-    // Legacy type 1: x"0001" + gas as u256 (200000 = 0x30d40)
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_1.to_be_bytes());
-    options.extend_from_slice(&hex!("0000000000000000000000000000000000000000000000000000000000030d40"));
-
-    let (executor_options, dvn_options) = split_worker_options(&env, &options);
-
-    // Expected: x"0100110100000000000000000000000000030d40"
-    assert_eq!(executor_options, Bytes::from_slice(&env, &hex!("0100110100000000000000000000000000030d40")));
-    assert_eq!(dvn_options.len(), 0);
-
-    // Verify by parsing
-    let mut reader = BufferReader::new(&executor_options);
-    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
-    assert_eq!(reader.read_u16(), 17);
-    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE);
-    assert_eq!(reader.read_u128(), 200000);
-    assert_eq!(reader.remaining_len(), 0);
-}
-
-#[test]
-fn test_decode_legacy_options_type_2() {
-    let env = Env::default();
-
-    // Legacy type 2: gas(u256) + amount(u256) + receiver(20 bytes)
-    // gas: 200000 (0x30d40), amount: 10000000 (0x989680), receiver: 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
-    let legacy_options = Bytes::from_slice(&env, &hex!("0000000000000000000000000000000000000000000000000000000000030d400000000000000000000000000000000000000000000000000000000000989680f39fd6e51aad88f6f4ce6ab8827279cfffb92266"));
-    let expected_options = hex!("0100110100000000000000000000000000030d400100310200000000000000000000000000989680000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266");
-
-    let executor_options = convert_legacy_options(&env, &mut BufferReader::new(&legacy_options), LEGACY_OPTIONS_TYPE_2);
-
-    // adapter params type 2 includes both lzReceive and nativeDrop
-    assert_eq!(executor_options, Bytes::from_slice(&env, &expected_options));
-
-    // Verify by parsing
-    let mut reader = BufferReader::new(&executor_options);
-
-    // lzReceive option
-    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
-    assert_eq!(reader.read_u16(), 17);
-    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE);
-    assert_eq!(reader.read_u128(), 200000);
-
-    // nativeDrop option
-    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
-    assert_eq!(reader.read_u16(), 49);
-    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_NATIVE_DROP);
-    assert_eq!(reader.read_u128(), 10000000);
-    assert_eq!(
-        reader.read_bytes_n(),
-        BytesN::from_array(&env, &hex!("000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266"))
-    );
-}
-
-#[test]
-fn test_split_worker_options_using_legacy_option() {
-    let env = Env::default();
-
-    // Same as test_decode_legacy_options_type_2
-    let mut legacy_options = Bytes::new(&env);
-    legacy_options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
-    legacy_options.extend_from_slice(&hex!("0000000000000000000000000000000000000000000000000000000000030d400000000000000000000000000000000000000000000000000000000000989680f39fd6e51aad88f6f4ce6ab8827279cfffb92266"));
-    let expected_options = hex!("0100110100000000000000000000000000030d400100310200000000000000000000000000989680000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266");
-
-    let (executor_options, _) = split_worker_options(&env, &legacy_options);
-
-    // adapter params type 2 includes both lzReceive and nativeDrop
-    assert_eq!(executor_options, Bytes::from_slice(&env, &expected_options));
-
-    let mut reader = BufferReader::new(&executor_options);
-
-    // lzReceive
-    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
-    assert_eq!(reader.read_u16(), 17);
-    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_LZRECEIVE);
-    assert_eq!(reader.read_u128(), 200000);
-
-    // nativeDrop
-    assert_eq!(reader.read_u8(), EXECUTOR_WORKER_ID);
-    assert_eq!(reader.read_u16(), 49);
-    assert_eq!(reader.read_u8(), EXECUTOR_OPTION_TYPE_NATIVE_DROP);
-    assert_eq!(reader.read_u128(), 10000000);
-    assert_eq!(
-        reader.read_bytes_n(),
-        BytesN::from_array(&env, &hex!("000000000000000000000000f39fd6e51aad88f6f4ce6ab8827279cfffb92266"))
-    );
-}
-
-#[test]
-fn test_group_dvn_options_by_index() {
-    let env = Env::default();
-
-    let dvn_option_bytes = hex!("020002000102000302ff0102000200010200020101");
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
-    options.extend_from_slice(&dvn_option_bytes);
-
-    let (_, dvn_options) = split_worker_options(&env, &options);
-
-    let expected_dvn_0_options = hex!("02000200010200020001"); // 2 DVN options, id = 0
-    let expected_dvn_1_options = hex!("0200020101"); // 1 DVN option, id = 1
-    let expected_dvn_2_options = hex!("02000302ff01"); // 1 DVN option, id = 2
-
-    let mut found_0 = false;
-    let mut found_1 = false;
-    let mut found_2 = false;
-
-    // Check that DVN options are grouped correctly by index
-    for (index, option) in dvn_options.iter() {
-        if index == 0 {
-            found_0 = true;
-            assert_eq!(option, Bytes::from_slice(&env, &expected_dvn_0_options));
-        }
-        if index == 1 {
-            found_1 = true;
-            assert_eq!(option, Bytes::from_slice(&env, &expected_dvn_1_options));
-        }
-        if index == 2 {
-            found_2 = true;
-            assert_eq!(option, Bytes::from_slice(&env, &expected_dvn_2_options));
-        }
-    }
-    assert!(found_0 && found_1 && found_2);
-}
-
-#[test]
-fn test_get_matching_options() {
-    let env = Env::default();
-
-    // Same DVN options as test_split_worker_options_dvn_only
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
-    options.extend_from_slice(&hex!("020002000102000302ff0102000200010200020101"));
-
-    let (_, dvn_options) = split_worker_options(&env, &options);
-
-    assert_eq!(dvn_options.get(0).unwrap(), Bytes::from_slice(&env, &hex!("02000200010200020001")));
-    assert_eq!(dvn_options.get(1).unwrap(), Bytes::from_slice(&env, &hex!("0200020101")));
-    assert_eq!(dvn_options.get(2).unwrap(), Bytes::from_slice(&env, &hex!("02000302ff01")));
-}
-
-// ============ Error tests ============
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1105)")] // WorkerOptionsError::InvalidOptions
-fn test_decode_invalid_options_too_short() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.push_back(OPTIONS_TYPE_3 as u8);
-    split_worker_options(&env, &options);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1106)")] // WorkerOptionsError::InvalidWorkerId
-fn test_decode_invalid_worker_id() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&OPTIONS_TYPE_3.to_be_bytes());
-    options.extend_from_slice(&hex!("00000501020304050607")); // Invalid worker_id = 0
-    split_worker_options(&env, &options);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1107)")] // WorkerOptionsError::LegacyOptionsType1GasOverflow
-fn test_legacy_type1_gas_overflow() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_1.to_be_bytes());
-    options.extend_from_slice(&hex!("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")); // u256 max
-    split_worker_options(&env, &options);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1109)")] // WorkerOptionsError::LegacyOptionsType2GasOverflow
-fn test_legacy_type2_gas_overflow() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
-    options.extend_from_slice(&hex!("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000000003e84242424242424242424242424242424242424242424242424242424242424242"));
-    split_worker_options(&env, &options);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1108)")] // WorkerOptionsError::LegacyOptionsType2AmountOverflow
-fn test_legacy_type2_amount_overflow() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
-    options.extend_from_slice(&hex!("0000000000000000000000000000000000000000000000000000000000030d40ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff4242424242424242424242424242424242424242424242424242424242424242"));
-    split_worker_options(&env, &options);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1102)")] // WorkerOptionsError::InvalidLegacyOptionsType1
-fn test_legacy_type1_invalid_size_too_short() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_1.to_be_bytes());
-    options.extend_from_slice(&hex!("00000000000000000000000000000000")); // Only 16 bytes
-    split_worker_options(&env, &options);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1102)")] // WorkerOptionsError::InvalidLegacyOptionsType1
-fn test_legacy_type1_invalid_size_too_long() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_1.to_be_bytes());
-    options.extend_from_slice(&hex!(
-        "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
-    )); // 48 bytes
-    split_worker_options(&env, &options);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1103)")] // WorkerOptionsError::InvalidLegacyOptionsType2
-fn test_legacy_type2_invalid_size_too_short() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
-    options.extend_from_slice(&hex!("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")); // 64 bytes, no receiver
-    split_worker_options(&env, &options);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1103)")] // WorkerOptionsError::InvalidLegacyOptionsType2
-fn test_legacy_type2_invalid_size_too_long() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&LEGACY_OPTIONS_TYPE_2.to_be_bytes());
-    options.extend_from_slice(&[0u8; 97]); // 97 bytes, too long
-    split_worker_options(&env, &options);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1104)")] // WorkerOptionsError::InvalidOptionType
-fn test_unsupported_option_type() {
-    let env = Env::default();
-    let mut options = Bytes::new(&env);
-    options.extend_from_slice(&hex!("0063")); // Invalid type 99
-    options.extend_from_slice(&hex!("0000000000000000000000000000000000000000000000000000000000000000"));
-    split_worker_options(&env, &options);
-}

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

@@ -1,154 +0,0 @@
-//! # 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)
-//! - **OAppSender**: Enables sending cross-chain messages through LayerZero
-//! - **OAppReceiver**: Handles incoming cross-chain messages
-//! - **OAppOptionsType3**: Manages enforced options for message execution parameters
-//!
-//! ## Available Macros
-//!
-//! ### `#[oapp]`
-//! The main macro that provides Core + Sender + Receiver + OptionsType3 functionality.
-//! This is the only macro you need for cross-chain communication.
-//!
-//! ### `#[oapp_manual_impl(...)]`
-//! A marker attribute to indicate which trait implementations should be manually provided
-//! by the user instead of using default implementations.
-//!
-//! ## Manual Implementation Control
-//!
-//! By default, `#[oapp]` generates default trait implementations. Use `#[oapp_manual_impl(...)]`
-//! to customize specific behaviors:
-//!
-//! Supported options:
-//! - `core` - Manually implement `OAppCore`
-//! - `sender` - Manually implement `OAppSender`
-//! - `receiver` - Manually implement `OAppReceiver` (useful for custom `next_nonce`, etc.)
-//! - `options_type3` - Manually implement `OAppOptionsType3`
-//!
-//! ## Examples
-//!
-//! ### Full OApp with Default Implementations
-//!
-//! ```ignore
-//! use oapp_macros::oapp;
-//!
-//! #[oapp]
-//! struct MyOApp;
-//!
-//! // Only __lz_receive must be implemented as an inherent method
-//! impl MyOApp {
-//!     fn __lz_receive(
-//!         env: &Env,
-//!         executor: &Address,
-//!         origin: &Origin,
-//!         guid: &BytesN<32>,
-//!         message: &Bytes,
-//!         extra_data: &Bytes,
-//!         value: i128,
-//!     ) {
-//!         // Your message handling logic (verify_and_clear_payload already called)
-//!     }
-//! }
-//! ```
-//!
-//! ### OApp with Custom Core Version
-//!
-//! ```ignore
-//! #[oapp]
-//! #[oapp_manual_impl(core)]
-//! struct MyOApp;
-//!
-//! #[contractimpl(contracttrait)]
-//! #[common_macros::ownable]
-//! impl OAppCore for MyOApp {
-//!     fn oapp_version(_env: &Env) -> (u64, u64) {
-//!         (1, 1) // Custom version
-//!     }
-//! }
-//!
-//! impl MyOApp {
-//!     fn __lz_receive(...) { /* ... */ }
-//! }
-//! ```
-//!
-//! ### OApp with Custom Receiver (e.g., ordered delivery)
-//!
-//! ```ignore
-//! use oapp::oapp_receiver::{OAppReceiver, verify_and_clear_payload};
-//!
-//! #[oapp]
-//! #[oapp_manual_impl(receiver)]
-//! struct MyOrderedOApp;
-//!
-//! #[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
-//!     }
-//!     fn lz_receive(env: &Env, executor: &Address, origin: &Origin, ...) {
-//!         verify_and_clear_payload::<Self>(env, executor, origin, guid, message, value);
-//!         // Your message handling logic
-//!     }
-//! }
-//! ```
-//!
-//! ### OApp with Multiple Manual Implementations
-//!
-//! ```ignore
-//! #[oapp]
-//! #[oapp_manual_impl(core, sender, options_type3)]
-//! struct MyCustomOApp;
-//!
-//! #[contractimpl(contracttrait)]
-//! #[common_macros::ownable]
-//! impl OAppCore for MyCustomOApp { /* ... */ }
-//! impl OAppSender for MyCustomOApp { /* ... */ }
-//! #[contractimpl(contracttrait)]
-//! impl OAppOptionsType3 for MyCustomOApp { /* ... */ }
-//!
-//! impl MyCustomOApp {
-//!     fn __lz_receive(...) { /* ... */ }
-//! }
-//! ```
-
-use crate::util::parse_struct;
-use proc_macro::TokenStream;
-
-mod oapp_core;
-mod oapp_full;
-mod oapp_options_type3;
-mod oapp_receiver;
-mod oapp_sender;
-mod util;
-
-/// Derives a complete OApp: `#[contract]` + `#[ownable]` + Core + Sender + Receiver + OptionsType3.
-///
-/// You must implement `__lz_receive` as an inherent method. See module docs for examples.
-#[proc_macro_attribute]
-pub fn oapp(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let (name, item, disable_config) = match parse_struct(item) {
-        Ok(result) => result,
-        Err(e) => return e,
-    };
-    oapp_full::generate_impl(&name, item, disable_config).into()
-}
-
-/// Marker attribute to skip generating specific trait implementations.
-///
-/// Supported options: `core`, `sender`, `receiver`, `options_type3`
-///
-/// Example: `#[oapp_manual_impl(core, receiver)]` skips generating
-/// `OAppCore` and `OAppReceiver` implementations.
-#[proc_macro_attribute]
-pub fn oapp_manual_impl(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    item
-}

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

@@ -1,40 +0,0 @@
-use heck::ToSnakeCase;
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{Ident, ItemStruct};
-
-/// Generates the `OAppCore` trait implementation and adds `#[contract]` + `#[ownable]` to the struct.
-///
-/// When `manual_impl_core` is false, generates an empty `impl OAppCore`
-/// that uses the trait's default implementations for peer management and endpoint access.
-pub fn generate_impl(name: &Ident, item_struct: ItemStruct, manual_impl_core: bool) -> TokenStream {
-    // Create a unique module name to avoid import conflicts when multiple structs
-    // use oapp macros in the same module. The import must be `OAppCore`
-    // (not an alias) because Soroban SDK's #[contractimpl(contracttrait)] generates
-    // a macro call `OAppCore!(...)` that needs to resolve to the macro
-    // exported by #[contracttrait].
-    let impl_mod = syn::Ident::new(&format!("__oapp_impl_{}", name.to_string().to_snake_case()), name.span());
-
-    let manual_impl = (!manual_impl_core).then(|| {
-        quote! {
-            #[doc(hidden)]
-            mod #impl_mod {
-                use super::*;
-                // Import types used by OAppCore trait's default implementations
-                use soroban_sdk::{Address, BytesN, Env};
-                use oapp::oapp_core::OAppCore;
-
-                #[soroban_sdk::contractimpl(contracttrait)]
-                impl OAppCore for #name {}
-            }
-        }
-    });
-
-    quote! {
-        #[soroban_sdk::contract]
-        #[common_macros::ttl_configurable]
-        #item_struct
-
-        #manual_impl
-    }
-}

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

@@ -1,21 +0,0 @@
-use crate::{oapp_core, oapp_options_type3, oapp_receiver, oapp_sender, util::ManualImplConfig};
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::{Ident, ItemStruct};
-
-/// Generates the full OApp implementation: Core + Sender + Receiver + OptionsType3.
-///
-/// Combines all OApp components. Use `manual_impl_config` to skip generating
-/// specific trait implementations when custom implementations are needed.
-pub fn generate_impl(name: &Ident, item: ItemStruct, manual_impl_config: ManualImplConfig) -> TokenStream {
-    let core_impl = oapp_core::generate_impl(name, item, manual_impl_config.core);
-    let sender_impl = oapp_sender::generate_impl(name, manual_impl_config.sender);
-    let receiver_impl = oapp_receiver::generate_impl(name, manual_impl_config.receiver);
-    let options_type3_impl = oapp_options_type3::generate_impl(name, manual_impl_config.options_type3);
-    quote! {
-        #core_impl
-        #sender_impl
-        #receiver_impl
-        #options_type3_impl
-    }
-}

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

@@ -1,31 +0,0 @@
-use heck::ToSnakeCase;
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::Ident;
-
-/// Generates the `OAppOptionsType3` trait implementation.
-///
-/// When `manual_impl_options_type3` is false, generates an empty `impl OAppOptionsType3`
-/// that uses the trait's default implementations for enforced options management.
-pub fn generate_impl(name: &Ident, manual_impl_options_type3: bool) -> TokenStream {
-    let impl_mod =
-        syn::Ident::new(&format!("__oapp_options_type3_impl_{}", name.to_string().to_snake_case()), name.span());
-
-    let options_type3_impl = (!manual_impl_options_type3).then(|| {
-        quote! {
-            #[doc(hidden)]
-            mod #impl_mod {
-                use super::*;
-                use soroban_sdk::{Env, Bytes, Vec};
-                use oapp::oapp_options_type3::{OAppOptionsType3, EnforcedOptionParam};
-
-                #[soroban_sdk::contractimpl(contracttrait)]
-                impl OAppOptionsType3 for #name {}
-            }
-        }
-    });
-
-    quote! {
-        #options_type3_impl
-    }
-}

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

@@ -1,48 +0,0 @@
-use heck::ToSnakeCase;
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::Ident;
-
-/// Generates the `OAppReceiver` trait implementation.
-///
-/// When `manual_impl_receiver` is false, generates `lz_receive` that calls
-/// `verify_and_clear_payload` then delegates to the user's `__lz_receive` method.
-pub fn generate_impl(name: &Ident, manual_impl_receiver: bool) -> TokenStream {
-    // Use a distinct module name to avoid conflicts with oapp_core's module
-    let impl_mod = syn::Ident::new(&format!("__oapp_receiver_impl_{}", name.to_string().to_snake_case()), name.span());
-
-    let receiver_impl = (!manual_impl_receiver).then(|| {
-        quote! {
-            // OAppReceiver implementation
-            // This generates contract entry points that are callable via LayerZeroReceiverClient
-            // because the function names match ILayerZeroReceiver's interface.
-            #[doc(hidden)]
-            mod #impl_mod {
-                use super::*;
-                use soroban_sdk::{Address, Bytes, BytesN, Env};
-                use endpoint_v2::Origin;
-                use oapp::oapp_receiver::OAppReceiver;
-
-                #[soroban_sdk::contractimpl(contracttrait)]
-                impl OAppReceiver for #name {
-                    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, value);
-                        Self::__lz_receive(env, executor, origin, guid, message, extra_data, value)
-                    }
-                }
-            }
-        }
-    });
-
-    quote! {
-        #receiver_impl
-    }
-}

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

@@ -1,21 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::Ident;
-
-/// Generates the `OAppSender` trait implementation.
-///
-/// When `manual_impl_sender` is false, generates an empty `impl OAppSender`
-/// that uses the trait's default implementations for `lz_quote` and `lz_send`...
-pub fn generate_impl(name: &Ident, manual_impl_sender: bool) -> TokenStream {
-    let sender_impl = (!manual_impl_sender).then(|| {
-        quote! {
-            use oapp::oapp_sender::OAppSender as _;
-
-            impl oapp::oapp_sender::OAppSender for #name {}
-        }
-    });
-
-    quote! {
-        #sender_impl
-    }
-}