@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

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

@@ -0,0 +1,128 @@
+//! Code generators for OApp trait implementations.
+
+use crate::CustomImpls;
+use heck::ToSnakeCase;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Ident, ItemStruct};
+
+/// Generates a complete OApp implementation with contract attributes and trait implementations.
+///
+/// This function creates:
+/// - `#[common_macros::lz_contract]` - Wrapper macro that combines:
+///   - `#[soroban_sdk::contract]` - Makes the struct a Soroban contract
+///   - `#[common_macros::ttl_configurable]` - Adds TTL configuration with auth
+///   - `#[common_macros::ttl_extendable]` - Adds manual TTL extension support
+///   - `#[common_macros::ownable]` - Adds single-owner access control
+/// - OAppCore, OAppSenderInternal, OAppReceiver, and OAppOptionsType3 trait implementations
+///
+/// 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);
+    quote! {
+        #[common_macros::lz_contract]
+        #item
+
+        #core_impl
+        #sender_impl
+        #receiver_impl
+        #options_type3_impl
+    }
+}
+
+/// 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();
+    }
+
+    let impl_mod = impl_mod_ident(name, "core");
+
+    quote! {
+        #[doc(hidden)]
+        mod #impl_mod {
+            use super::*;
+            use oapp::oapp_core::OAppCore;
+
+            #[soroban_sdk::contractimpl(contracttrait)]
+            impl OAppCore for #name {}
+        }
+    }
+}
+
+/// 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 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`).
+///
+/// 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();
+    }
+
+    let impl_mod = impl_mod_ident(name, "receiver");
+
+    quote! {
+        #[doc(hidden)]
+        mod #impl_mod {
+            use super::*;
+            use oapp::oapp_receiver::OAppReceiver;
+
+            #[soroban_sdk::contractimpl(contracttrait)]
+            impl OAppReceiver for #name {}
+        }
+    }
+}
+
+/// 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();
+    }
+
+    let impl_mod = impl_mod_ident(name, "options_type3");
+
+    quote! {
+        #[doc(hidden)]
+        mod #impl_mod {
+            use super::*;
+            use soroban_sdk::Vec;
+            use oapp::oapp_options_type3::{EnforcedOptionParam, OAppOptionsType3};
+
+            #[soroban_sdk::contractimpl(contracttrait)]
+            impl OAppOptionsType3 for #name {}
+        }
+    }
+}
+
+/// Creates a unique hidden module identifier for trait implementations.
+fn impl_mod_ident(struct_name: &Ident, trait_name: &str) -> Ident {
+    Ident::new(&format!("__oapp_{}_impl_{}", trait_name, struct_name.to_string().to_snake_case()), struct_name.span())
+}

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

@@ -8,53 +8,51 @@
 //! 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
+//! - **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
 //!
-//! ## Available Macros
+//! ## Usage
 //!
 //! ### `#[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.
+//! ### Custom Implementations
 //!
-//! ## Manual Implementation Control
-//!
-//! By default, `#[oapp]` generates default trait implementations. Use `#[oapp_manual_impl(...)]`
-//! to customize specific behaviors:
+//! By default, `#[oapp]` generates default trait implementations. Use `#[oapp(custom = [...])]`
+//! to provide your own custom implementations for specific traits:
 //!
 //! 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`
+//! - `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]
 //! struct MyOApp;
 //!
-//! // Only __lz_receive must be implemented as an inherent method
-//! impl MyOApp {
+//! // Implement LzReceiveInternal to handle incoming messages
+//! impl LzReceiveInternal for MyOApp {
 //!     fn __lz_receive(
 //!         env: &Env,
-//!         executor: &Address,
 //!         origin: &Origin,
 //!         guid: &BytesN<32>,
 //!         message: &Bytes,
 //!         extra_data: &Bytes,
+//!         executor: &Address,
 //!         value: i128,
 //!     ) {
-//!         // Your message handling logic (verify_and_clear_payload already called)
+//!         // Your message handling logic (clear_payload_and_transfer already called)
 //!     }
 //! }
 //! ```
@@ -62,8 +60,9 @@
 //! ### OApp with Custom Core Version
 //!
 //! ```ignore
-//! #[oapp]
-//! #[oapp_manual_impl(core)]
+//! use oapp::oapp_receiver::LzReceiveInternal;
+//!
+//! #[oapp(custom = [core])]
 //! struct MyOApp;
 //!
 //! #[contractimpl(contracttrait)]
@@ -74,7 +73,7 @@
 //!     }
 //! }
 //!
-//! impl MyOApp {
+//! impl LzReceiveInternal for MyOApp {
 //!     fn __lz_receive(...) { /* ... */ }
 //! }
 //! ```
@@ -82,73 +81,131 @@
 //! ### OApp with Custom Receiver (e.g., ordered delivery)
 //!
 //! ```ignore
-//! use oapp::oapp_receiver::{OAppReceiver, verify_and_clear_payload};
+//! use oapp::oapp_receiver::{LzReceiveInternal, OAppReceiver};
 //!
-//! #[oapp]
-//! #[oapp_manual_impl(receiver)]
+//! #[oapp(custom = [receiver])]
 //! 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
 //!     }
-//!     fn lz_receive(env: &Env, executor: &Address, origin: &Origin, ...) {
-//!         verify_and_clear_payload::<Self>(env, executor, origin, guid, message, value);
-//!         // Your message handling logic
-//!     }
+//!     // lz_receive uses default impl which calls clear_payload_and_transfer then __lz_receive
 //! }
 //! ```
 //!
-//! ### OApp with Multiple Manual Implementations
+//! ### OApp with Multiple Custom Implementations
 //!
 //! ```ignore
-//! #[oapp]
-//! #[oapp_manual_impl(core, sender, options_type3)]
+//! use oapp::oapp_receiver::LzReceiveInternal;
+//!
+//! #[oapp(custom = [core, sender, options_type3])]
 //! struct MyCustomOApp;
 //!
 //! #[contractimpl(contracttrait)]
 //! #[common_macros::ownable]
 //! impl OAppCore for MyCustomOApp { /* ... */ }
-//! impl OAppSender for MyCustomOApp { /* ... */ }
+//! impl OAppSenderInternal for MyCustomOApp { /* ... */ }
 //! #[contractimpl(contracttrait)]
 //! impl OAppOptionsType3 for MyCustomOApp { /* ... */ }
 //!
-//! impl MyCustomOApp {
+//! impl LzReceiveInternal for MyCustomOApp {
 //!     fn __lz_receive(...) { /* ... */ }
 //! }
 //! ```
 
-use crate::util::parse_struct;
-use proc_macro::TokenStream;
+mod generators;
 
-mod oapp_core;
-mod oapp_full;
-mod oapp_options_type3;
-mod oapp_receiver;
-mod oapp_sender;
-mod util;
+use proc_macro::TokenStream;
+use syn::{
+    bracketed,
+    parse::{Parse, ParseStream},
+    punctuated::Punctuated,
+    Error, Ident, ItemStruct, Token,
+};
 
 /// Derives a complete OApp: `#[contract]` + `#[ownable]` + Core + Sender + Receiver + OptionsType3.
 ///
-/// You must implement `__lz_receive` as an inherent method. See module docs for examples.
+/// ## 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 {
-    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()
+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()
 }
 
-/// Marker attribute to skip generating specific trait implementations.
-///
-/// Supported options: `core`, `sender`, `receiver`, `options_type3`
+/// Specifies which OApp trait implementations the user will provide themselves.
 ///
-/// 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
+/// 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,
+}
+
+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)
+    }
 }

package/contracts/oapps/oft/Cargo.toml

@@ -5,15 +5,22 @@ edition.workspace = true
 license.workspace = true
 
 [lib]
-crate-type = ["rlib"]
+crate-type = ["cdylib", "rlib"]
 doctest = false
 
+[features]
+library = []
+testutils = []
+
 [dependencies]
 soroban-sdk = { workspace = true }
-endpoint-v2 = { workspace = true, features = ["library"] }
+cfg-if = { workspace = true }
 utils = { workspace = true }
-oapp = { workspace = true }
 common-macros = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+oapp = { workspace = true }
+oapp-macros = { workspace = true }
+oft-core = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
@@ -21,7 +28,3 @@ simple-message-lib = { workspace = true }
 message-lib-common = { workspace = true, features = ["testutils"] }
 endpoint-v2 = { workspace = true, features = ["testutils"] }
 utils = { workspace = true, features = ["testutils"] }
-insta = { workspace = true }
-oapp-macros = { workspace = true }
-stellar-macros = { workspace = true }
-stellar-tokens = { workspace = true }

package/contracts/oapps/{oft-std → oft}/integration-tests/extensions/test_oft_fee.rs

@@ -8,10 +8,9 @@
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
-        address_to_peer_bytes32, create_send_param, lz_receive, mint_to,
-        quote_oft, quote_send, scan_packet_sent_event, send, send_with_fee,
-        set_default_fee_bps, set_fee_bps, set_fee_deposit_address, token_balance,
-        transfer_sac_admin, validate_packet,
+        address_to_peer_bytes32, create_send_param, lz_receive, mint_to, quote_oft, quote_send,
+        scan_packet_sent_event, send, send_with_fee, set_default_fee_bps, set_fee_bps, set_fee_deposit_address,
+        token_balance, transfer_sac_admin, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};

package/contracts/oapps/{oft-std → oft}/integration-tests/extensions/test_pausable.rs

@@ -6,9 +6,8 @@
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
-        address_to_peer_bytes32, create_send_param, is_paused, lz_receive, mint_to,
-        quote_oft, quote_send, scan_packet_sent_event, send, set_paused, transfer_sac_admin,
-        try_lz_receive, try_send, validate_packet,
+        address_to_peer_bytes32, create_send_param, is_paused, lz_receive, mint_to, quote_oft, quote_send,
+        scan_packet_sent_event, send, set_paused, transfer_sac_admin, try_lz_receive, try_send, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};

package/contracts/oapps/{oft-std → oft}/integration-tests/extensions/test_rate_limiter.rs

@@ -3,6 +3,7 @@
 //! Tests verify that the RateLimiter extension properly enforces rate limits
 //! on cross-chain transfers. Uses real EndpointV2 and SimpleMessageLib.
 
+use crate::extensions::rate_limiter::Direction;
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
@@ -11,7 +12,6 @@ use crate::integration_tests::{
         try_send, validate_packet,
     },
 };
-use oft::extensions::rate_limiter::Direction;
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
 
 /// Test e2e send without rate limit (default - unlimited)

package/contracts/oapps/oft/integration-tests/mod.rs

@@ -1,3 +1,3 @@
+pub mod extensions;
 pub mod setup;
-pub mod test_with_sml;
 pub mod utils;

package/contracts/oapps/oft/integration-tests/setup.rs

@@ -1,123 +1,39 @@
-//! Integration test setup for OFT.
+//! Integration test setup for OFT-STD with real EndpointV2 and SimpleMessageLib.
 //!
-//! This file contains TestOFT contract and test setup utilities.
+//! This file contains test setup utilities for OFT-STD with all extensions enabled.
 
-extern crate self as oft;
 extern crate std;
 
-use crate::integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address};
-use common_macros::contract_impl;
-use endpoint_v2::{EndpointV2, EndpointV2Client, ILayerZeroComposer};
-use oft::oft::{oft_initialize, OFTClient, OFTInternal, OFT};
-use oft::storage::OFTStorage;
-use oft::types::OFTReceipt;
+use crate::{
+    integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address},
+    oft::{OFTClient, OFT},
+    oft_types::OftType,
+};
+use endpoint_v2::{EndpointV2, EndpointV2Client};
 use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
-use soroban_sdk::contractimpl;
 use soroban_sdk::{
-    contract, contracttype, log, symbol_short,
+    contract, contractimpl, log,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
-    token::{StellarAssetClient, TokenClient},
-    Address, Bytes, BytesN, Env, IntoVal,
+    token::TokenClient,
+    Address, BytesN, Env, IntoVal,
 };
 
 // ============================================================================
-// Test OFT Contract
+// Dummy Recipient - used to create valid contract addresses for recipients
 // ============================================================================
 
-#[oapp_macros::oapp]
-pub struct TestOFT;
-
-#[contract_impl]
-impl TestOFT {
-    pub fn __constructor(
-        env: &Env,
-        token: &Address,
-        owner: &Address,
-        endpoint: &Address,
-        delegate: &Option<Address>,
-        shared_decimals: u32,
-    ) {
-        oft_initialize::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
-    }
-}
-
-#[contractimpl(contracttrait)]
-impl OFT for TestOFT {}
-
-impl OFTInternal for TestOFT {
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        // Get the receipt (handles decimal conversion, fees, etc.)
-        let receipt = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
-        // Actually burn tokens from sender
-        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).burn(sender, &receipt.amount_sent_ld);
-        receipt
-    }
-
-    fn __credit(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
-        // Actually mint tokens to recipient
-        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).mint(to, &amount_ld);
-        amount_ld
-    }
-}
-
-// ============================================================================
-// Dummy Composer for testing compose messages
-// ============================================================================
-
-#[contracttype]
-pub struct ComposeMessage {
-    pub executor: Address,
-    pub from: Address,
-    pub guid: BytesN<32>,
-    pub index: u32,
-    pub message: Bytes,
-    pub extra_data: Bytes,
-    pub value: i128,
-}
-
 #[contract]
-pub struct DummyComposer;
-
-#[contract_impl]
-impl DummyComposer {
-    pub fn __constructor(env: &Env, endpoint: &Address) {
-        env.storage().instance().set(&symbol_short!("endpoint"), endpoint);
-    }
+pub struct DummyRecipient;
 
-    pub fn compose_message(env: &Env) -> Option<ComposeMessage> {
-        env.storage().instance().get(&symbol_short!("msg"))
-    }
+#[contractimpl]
+impl DummyRecipient {
+    pub fn __constructor(_env: &Env) {}
 }
 
-#[contract_impl]
-impl ILayerZeroComposer for DummyComposer {
-    fn lz_compose(
-        env: &Env,
-        executor: &Address,
-        from: &Address,
-        guid: &BytesN<32>,
-        index: u32,
-        message: &Bytes,
-        extra_data: &Bytes,
-        value: i128,
-    ) {
-        let endpoint_address: Address = env.storage().instance().get(&symbol_short!("endpoint")).unwrap();
-        let endpoint = endpoint_v2::MessagingComposerClient::new(env, &endpoint_address);
-        endpoint.clear_compose(&env.current_contract_address(), from, guid, &index, message);
-
-        env.storage().instance().set(
-            &symbol_short!("msg"),
-            &ComposeMessage {
-                executor: executor.clone(),
-                from: from.clone(),
-                guid: guid.clone(),
-                index,
-                message: message.clone(),
-                extra_data: extra_data.clone(),
-                value,
-            },
-        );
-    }
+/// Creates a valid recipient address by deploying a dummy contract.
+/// Use this in tests when the address needs to pass the `.exists()` check.
+pub fn create_recipient_address(env: &Env) -> Address {
+    env.register(DummyRecipient, ())
 }
 
 // ============================================================================
@@ -128,16 +44,16 @@ pub struct ChainSetup<'a> {
     pub eid: u32,
     pub owner: Address,
     pub native_token: Address,
+    pub zro_token: Address,
     pub oft_token: Address,
     pub endpoint: EndpointV2Client<'a>,
     pub sml: SimpleMessageLibClient<'a>,
     pub oft: OFTClient<'a>,
-    pub composer: DummyComposerClient<'a>,
+    pub fee_collector: Address,
 }
 
 pub struct TestSetup<'a> {
     pub env: Env,
-
     pub chain_a: ChainSetup<'a>,
     pub chain_b: ChainSetup<'a>,
 }
@@ -145,9 +61,13 @@ pub struct TestSetup<'a> {
 fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let owner = Address::generate(env);
 
+    // Create native token FIRST - this must match the endpoint's NATIVE_TOKEN constant
     let sac = env.register_stellar_asset_contract_v2(owner.clone());
     let native_token = sac.address();
 
+    // Generate fee_collector AFTER native_token to not affect the address derivation
+    let fee_collector = Address::generate(env);
+
     // Create ZRO token
     let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let zro_token = zro_sac.address();
@@ -161,13 +81,12 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let sml_address = env.register(SimpleMessageLib, (&owner, &endpoint_address, &fee_recipient));
     let delegate: Option<Address> = Some(owner.clone());
     let shared_decimals: u32 = 6; // Default shared decimals
-    let oft_address = env.register(TestOFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals));
-    let composer_address = env.register(DummyComposer, (&endpoint_address,));
+    let mode = OftType::MintBurn;
+    let oft_address = env.register(OFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals, &mode));
 
     let endpoint = EndpointV2Client::new(env, &endpoint_address);
     let sml = SimpleMessageLibClient::new(env, &sml_address);
     let oft = OFTClient::new(env, &oft_address);
-    let composer = DummyComposerClient::new(env, &composer_address);
 
     // Set ZRO token in endpoint
     env.mock_auths(&[MockAuth {
@@ -184,7 +103,7 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     register_library(env, &owner, &endpoint, &sml.address);
 
     let eid = endpoint.eid();
-    ChainSetup { eid, owner, native_token, oft_token, endpoint, sml, oft, composer }
+    ChainSetup { eid, owner, native_token, zro_token, oft_token, endpoint, sml, oft, fee_collector }
 }
 
 pub fn setup<'a>() -> TestSetup<'a> {