@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

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

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

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

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

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

@@ -12,26 +12,29 @@ use syn::{
 /// which default trait implementations are generated by the macros.
 ///
 /// # Fields
-/// * `core` - If `true`, the user must manually implement `OAppCoreOverrides`
-/// * `sender` - If `true`, the user must manually implement `OAppSenderOverrides`  
-/// * `options_type3` - If `true`, the user must manually implement `OAppOptionsType3Overrides`
+/// * `core` - If `true`, the user must manually implement `OAppCore`
+/// * `sender` - If `true`, the user must manually implement `OAppSender`
+/// * `receiver` - If `true`, the user must manually implement `OAppReceiver` trait entirely
+/// * `options_type3` - If `true`, the user must manually implement `OAppOptionsType3`
 ///
-/// # Note on Receiver
-/// There is intentionally **no** `receiver` field in this config because the receiver
-/// always requires manual implementation. The `OAppReceiverOverrides::__lz_receive` method
-/// has no default implementation, so users must always provide their own implementation
-/// of the message handling logic.
+/// # Receiver Manual Implementation
+/// When `receiver` is `true`, the macro will NOT generate `impl OAppReceiver`. The user
+/// must manually implement the entire `OAppReceiver` trait, including `lz_receive`,
+/// `next_nonce`, `allow_initialize_path`, and `is_compose_msg_sender`.
+///
+/// This is useful when you need to customize methods like `next_nonce` (e.g., for ordered delivery).
 #[derive(Debug, Clone, Copy, Default)]
 pub struct ManualImplConfig {
     pub core: bool,
     pub sender: bool,
+    pub receiver: bool,
     pub options_type3: bool,
 }
 
 impl ManualImplConfig {
     /// Parses configuration from the `#[oapp_manual_impl(...)]` attribute arguments.
     ///
-    /// Accepts a comma-separated list of identifiers: `core`, `sender`, `options_type3`.
+    /// Accepts a comma-separated list of identifiers: `core`, `sender`, `receiver`, `options_type3`.
     /// Returns an error if any invalid identifier is provided.
     fn from_attr(input: ParseStream) -> syn::Result<Self> {
         let idents = Punctuated::<syn::Ident, Token![,]>::parse_terminated(input)?;
@@ -42,11 +45,12 @@ impl ManualImplConfig {
             match ident.to_string().as_str() {
                 "core" => cfg.core = true,
                 "sender" => cfg.sender = true,
+                "receiver" => cfg.receiver = true,
                 "options_type3" => cfg.options_type3 = true,
                 _ => {
                     return Err(Error::new(
                         ident.span(),
-                        "invalid value for oapp_manual_impl: expected one of `core`, `sender`, `options_type3`",
+                        "invalid value for oapp_manual_impl: expected one of `core`, `sender`, `receiver`, `options_type3`",
                     ));
                 }
             }

package/contracts/oapps/counter/Cargo.toml

@@ -21,4 +21,5 @@ soroban-sdk = { workspace = true, features = ["testutils"] }
 assert_unordered = "0.3.5"
 simple-message-lib = { workspace = true }
 message-lib-common = { workspace = true, features = ["testutils"] }
-endpoint-v2 = { workspace = true, features = ["testutils"] }
+endpoint-v2 = { workspace = true, features = ["testutils"] }
+executor = { workspace = true, features = ["testutils"] }

package/contracts/oapps/counter/integration_tests/utils.rs

@@ -59,11 +59,11 @@ pub fn validate_packet(env: &Env, chain: &ChainSetup<'_>, packet_event: &(Bytes,
         invoke: &MockAuthInvoke {
             contract: &chain.sml.address,
             fn_name: "validate_packet",
-            args: (&chain.owner, &encoded_header, &payload_hash).into_val(env),
+            args: (&encoded_header, &payload_hash).into_val(env),
             sub_invokes: &[],
         },
     }]);
-    chain.sml.validate_packet(&chain.owner, &encoded_header, &payload_hash);
+    chain.sml.validate_packet(&encoded_header, &payload_hash);
 }
 
 pub fn lz_receive(
@@ -78,8 +78,8 @@ pub fn lz_receive(
 
     let sub_invokes_with_transfer = [MockAuthInvoke {
         contract: &chain.native_token,
-        fn_name: "transfer_from",
-        args: (executor, executor, &chain.counter.address, &value).into_val(env),
+        fn_name: "transfer",
+        args: (executor, &chain.counter.address, &value).into_val(env),
         sub_invokes: &[],
     }];
 

package/contracts/oapps/counter/src/codec.rs

@@ -1,4 +1,7 @@
 use soroban_sdk::{Bytes, Env, U256};
+use utils::option_ext::OptionExt;
+
+use crate::{errors::CounterError, u256_ext::U256Ext};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(u8)]
@@ -36,10 +39,9 @@ pub fn encode(env: &Env, msg_type: MsgType, src_eid: u32) -> Bytes {
     data
 }
 
-pub fn encode_with_value(env: &Env, msg_type: MsgType, src_eid: u32, value: U256) -> Bytes {
+pub fn encode_with_value(env: &Env, msg_type: MsgType, src_eid: u32, value: u32) -> Bytes {
     let mut data = encode(env, msg_type, src_eid);
-    data.append(&value.to_be_bytes());
-
+    data.append(&U256::from_u32(env, value).to_be_bytes());
     data
 }
 
@@ -53,11 +55,8 @@ pub fn src_eid(data: &Bytes) -> u32 {
     u32::from_be_bytes(src_eid_bytes)
 }
 
-pub fn value(env: &Env, data: &Bytes) -> U256 {
+pub fn value(env: &Env, data: &Bytes) -> i128 {
     let slice = data.slice((VALUE_OFFSET as u32)..data.len());
-    if slice.is_empty() {
-        U256::from_u32(env, 0)
-    } else {
-        U256::from_be_bytes(env, &slice)
-    }
+    let value = if slice.is_empty() { U256::from_u32(env, 0) } else { U256::from_be_bytes(env, &slice) };
+    value.to_i128().unwrap_or_panic(env, CounterError::InvalidMsgValue)
 }

package/contracts/oapps/counter/src/counter.rs

@@ -1,129 +1,58 @@
 use crate::{
     codec::{self, MsgType},
     errors::CounterError,
-    options, storage,
-    u256_ext::U256Ext,
+    options,
+    storage::CounterStorage,
 };
-use common_macros::only_owner;
+use common_macros::{contract_impl, only_owner};
 use endpoint_v2::{
-    ILayerZeroComposer, ILayerZeroReceiver, LayerZeroEndpointV2Client, MessagingChannelClient, MessagingComposerClient,
-    MessagingFee, Origin,
+    ILayerZeroComposer, LayerZeroEndpointV2Client, MessagingChannelClient, MessagingComposerClient, MessagingFee,
+    Origin,
 };
-use oapp::{oapp_core::OAppCoreOverrides, oapp_receiver::OAppReceiverOverrides};
-use oapp_macros::oapp;
-use soroban_sdk::{
-    assert_with_error, contractimpl, panic_with_error, token::TokenClient, Address, Bytes, BytesN, Env, U256,
+use oapp::{
+    oapp_core::{oapp_initialize, OAppCore},
+    oapp_receiver::{self, OAppReceiver},
+    oapp_sender::OAppSender,
 };
-use utils::{option_ext::OptionExt, ownable::Ownable};
+use oapp_macros::{oapp, oapp_manual_impl};
+use soroban_sdk::{assert_with_error, panic_with_error, token::TokenClient, Address, Bytes, BytesN, Env};
+use utils::ownable::Ownable;
 
 #[oapp]
+#[oapp_manual_impl(receiver)]
 pub struct Counter;
 
-impl OAppReceiverOverrides for Counter {
-    fn __next_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>) -> u64 {
-        if storage::CounterStorage::ordered_nonce(env) {
-            storage::CounterStorage::max_received_nonce(env, src_eid, sender) + 1
-        } else {
-            0
-        }
-    }
-
-    fn __lz_receive(
-        env: &Env,
-        executor: &Address,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        _extra_data: &Bytes,
-        value: i128,
-    ) {
-        let endpoint_address = Self::endpoint(env);
-        let endpoint = LayerZeroEndpointV2Client::new(env, &endpoint_address);
-        let contract_address = env.current_contract_address();
-        if value > 0 {
-            let native_token = endpoint.native_token();
-            let token_client = TokenClient::new(env, &native_token);
-            token_client.transfer_from(executor, executor, &contract_address, &value);
-        }
-
-        // handle the message
-        Self::__accept_nonce(env, origin.src_eid, &origin.sender, origin.nonce);
-        let count = Self::count(env);
-        let inbound_count = Self::inbound_count(env, origin.src_eid);
-        let outbound_count = Self::outbound_count(env, origin.src_eid);
-        match codec::msg_type(message) {
-            MsgType::Vanilla => {
-                storage::CounterStorage::set_count(env, &(count + 1));
-
-                let expected_msg_value =
-                    codec::value(env, message).to_i128().unwrap_or_panic(env, CounterError::InvalidMsgValue);
-
-                assert_with_error!(env, value >= expected_msg_value, CounterError::InsufficientValue);
-
-                storage::CounterStorage::set_inbound_count(env, origin.src_eid, &(inbound_count + 1));
-            }
-            MsgType::Composed | MsgType::ComposedABA => {
-                storage::CounterStorage::set_count(env, &(count + 1));
-                storage::CounterStorage::set_inbound_count(env, origin.src_eid, &(inbound_count + 1));
-
-                let endpoint_address = Self::endpoint(env);
-                let endpoint: MessagingComposerClient<'_> = MessagingComposerClient::new(env, &endpoint_address);
-                endpoint.send_compose(&contract_address, &contract_address, guid, &0, message);
-            }
-            MsgType::ABA => {
-                storage::CounterStorage::set_count(env, &(count + 1));
-                storage::CounterStorage::set_inbound_count(env, origin.src_eid, &(inbound_count + 1));
-                storage::CounterStorage::set_outbound_count(env, origin.src_eid, &(outbound_count + 1));
-
-                let options = options::executor_lz_receive_option(env, 200000, 10);
-                Self::__lz_send(
-                    env,
-                    &contract_address,
-                    origin.src_eid,
-                    &codec::encode_with_value(env, MsgType::Vanilla, origin.src_eid, U256::from_u32(env, 10)),
-                    &options,
-                    &MessagingFee { native_fee: value, zro_fee: 0 },
-                    &contract_address,
-                );
-            }
-        }
-    }
-}
-
-#[contractimpl]
+#[contract_impl]
 impl Counter {
     pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Address) {
-        Self::__init_owner(env, owner);
-        Self::__oapp_initialize(env, endpoint, &Some(delegate.clone()));
+        oapp_initialize::<Self>(env, owner, endpoint, &Some(delegate.clone()));
         let endpoint_client = LayerZeroEndpointV2Client::new(env, endpoint);
-        storage::CounterStorage::set_eid(env, &endpoint_client.eid());
+        CounterStorage::set_eid(env, &endpoint_client.eid());
     }
 
     pub fn quote(env: &Env, dst_eid: u32, msg_type: u32, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
-        Self::__quote(env, dst_eid, &codec::encode(env, (msg_type as u8).into(), Self::eid(env)), options, pay_in_zro)
+        Self::lz_quote(env, dst_eid, &codec::encode(env, (msg_type as u8).into(), Self::eid(env)), options, pay_in_zro)
     }
 
-    pub fn increment(env: &Env, sender: &Address, dst_eid: u32, msg_type: u32, options: &Bytes, fee: &MessagingFee) {
-        sender.require_auth();
-
-        Self::__lz_send(
-            env,
-            sender,
-            dst_eid,
-            &codec::encode(env, (msg_type as u8).into(), Self::eid(env)),
-            options,
-            fee,
-            sender,
-        );
+    pub fn increment(env: &Env, caller: &Address, dst_eid: u32, msg_type: u32, options: &Bytes, fee: &MessagingFee) {
+        caller.require_auth();
+
+        // Increment the outbound count
         let outbound_count = Self::outbound_count(env, dst_eid);
-        storage::CounterStorage::set_outbound_count(env, dst_eid, &(outbound_count + 1));
+        CounterStorage::set_outbound_count(env, dst_eid, &(outbound_count + 1));
+
+        // Send the message
+        let message = codec::encode(env, (msg_type as u8).into(), Self::eid(env));
+        Self::lz_send(env, caller, dst_eid, &message, options, fee, caller);
     }
 
-    // === Owner functions ===
+    // ============================================================================================
+    // Owner functions
+    // ============================================================================================
 
     #[only_owner]
     pub fn set_ordered_nonce(env: &Env, ordered_nonce: bool) {
-        storage::CounterStorage::set_ordered_nonce(env, &ordered_nonce);
+        CounterStorage::set_ordered_nonce(env, &ordered_nonce);
     }
 
     #[only_owner]
@@ -134,102 +63,182 @@ impl Counter {
         let endpoint = MessagingChannelClient::new(env, &endpoint_address);
         endpoint.skip(&contract_address, &contract_address, &src_eid, sender, &nonce);
 
-        if storage::CounterStorage::ordered_nonce(env) {
-            let max_received_nonce = storage::CounterStorage::max_received_nonce(env, src_eid, sender);
-            storage::CounterStorage::set_max_received_nonce(env, src_eid, sender, &(max_received_nonce + 1));
+        if CounterStorage::ordered_nonce(env) {
+            let max_received_nonce = CounterStorage::max_received_nonce(env, src_eid, sender);
+            CounterStorage::set_max_received_nonce(env, src_eid, sender, &(max_received_nonce + 1));
         }
     }
 
-    // === view functions ===
+    // ============================================================================================
+    // View functions
+    // ============================================================================================
 
     pub fn eid(env: &Env) -> u32 {
-        storage::CounterStorage::eid(env).unwrap()
+        CounterStorage::eid(env).unwrap()
     }
 
     pub fn count(env: &Env) -> u64 {
-        storage::CounterStorage::count(env)
+        CounterStorage::count(env)
     }
 
     pub fn composed_count(env: &Env) -> u64 {
-        storage::CounterStorage::composed_count(env)
+        CounterStorage::composed_count(env)
     }
 
     pub fn inbound_count(env: &Env, eid: u32) -> u64 {
-        storage::CounterStorage::inbound_count(env, eid)
+        CounterStorage::inbound_count(env, eid)
     }
 
     pub fn outbound_count(env: &Env, eid: u32) -> u64 {
-        storage::CounterStorage::outbound_count(env, eid)
+        CounterStorage::outbound_count(env, eid)
     }
 
-    // === Internal functions ===
+    // ============================================================================================
+    // Internal Functions
+    // ============================================================================================
 
     fn __accept_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>, nonce: u64) {
-        let current_nonce = storage::CounterStorage::max_received_nonce(env, src_eid, sender);
-        if storage::CounterStorage::ordered_nonce(env) {
+        let current_nonce = CounterStorage::max_received_nonce(env, src_eid, sender);
+        if CounterStorage::ordered_nonce(env) {
             assert_with_error!(env, nonce == current_nonce + 1, CounterError::OAppInvalidNonce);
         }
-
+        // Update the max nonce anyway. once the ordered mode is turned on, missing early nonces will be rejected
         if nonce > current_nonce {
-            storage::CounterStorage::set_max_received_nonce(env, src_eid, sender, &nonce);
+            CounterStorage::set_max_received_nonce(env, src_eid, sender, &nonce);
         }
     }
 }
 
-#[contractimpl]
-impl ILayerZeroComposer for Counter {
-    fn lz_compose(
+// ============================================================================================
+// OAppReceiver implementation
+// ============================================================================================
+
+#[contract_impl(contracttrait)]
+impl OAppReceiver for Counter {
+    fn next_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>) -> u64 {
+        if CounterStorage::ordered_nonce(env) {
+            CounterStorage::max_received_nonce(env, src_eid, sender) + 1
+        } else {
+            0
+        }
+    }
+
+    fn lz_receive(
         env: &Env,
         executor: &Address,
-        from: &Address,
+        origin: &Origin,
         guid: &BytesN<32>,
-        index: u32,
         message: &Bytes,
         _extra_data: &Bytes,
         value: i128,
     ) {
-        executor.require_auth();
-        let contract_address = env.current_contract_address();
-        let endpoint_address = Self::endpoint(env);
+        oapp_receiver::verify_and_clear_payload::<Self>(env, executor, origin, guid, message, value);
 
-        // Transfer value from executor to contract for lz_send
-        if value > 0 {
-            let endpoint = LayerZeroEndpointV2Client::new(env, &endpoint_address);
-            let native_token = endpoint.native_token();
-            let token_client = TokenClient::new(env, &native_token);
-            token_client.transfer_from(executor, executor, &contract_address, &value);
-        }
+        // handle the message
+        Self::__accept_nonce(env, origin.src_eid, &origin.sender, origin.nonce);
 
-        let endpoint = MessagingComposerClient::new(env, &endpoint_address);
-        // try clear the compose first
-        endpoint.clear_compose(&contract_address, from, guid, &index, message);
+        let contract_address = env.current_contract_address();
 
-        // handle the message
-        let composed_count = Self::composed_count(env);
+        // Increment the count and inbound count
+        let count = Self::count(env);
+        let inbound_count = Self::inbound_count(env, origin.src_eid);
+        CounterStorage::set_count(env, &(count + 1));
+        CounterStorage::set_inbound_count(env, origin.src_eid, &(inbound_count + 1));
+
+        let assert_received_value = || {
+            let expected_msg_value = codec::value(env, message);
+            assert_with_error!(env, value >= expected_msg_value, CounterError::InsufficientValue);
+        };
 
         match codec::msg_type(message) {
-            MsgType::Composed => {
-                storage::CounterStorage::set_composed_count(env, &(composed_count + 1));
+            MsgType::Vanilla => {
+                assert_received_value();
+            }
+            MsgType::Composed | MsgType::ComposedABA => {
+                let endpoint: MessagingComposerClient<'_> = MessagingComposerClient::new(env, &Self::endpoint(env));
+                endpoint.send_compose(&contract_address, &contract_address, guid, &0, message);
             }
-            MsgType::ComposedABA => {
-                storage::CounterStorage::set_composed_count(env, &(composed_count + 1));
+            MsgType::ABA => {
+                assert_received_value();
 
-                let src_eid = codec::src_eid(message);
-                let outbound_count = Self::outbound_count(env, src_eid);
-                storage::CounterStorage::set_outbound_count(env, src_eid, &(outbound_count + 1));
+                // Increment the outbound count
+                let outbound_count = Self::outbound_count(env, origin.src_eid);
+                CounterStorage::set_outbound_count(env, origin.src_eid, &(outbound_count + 1));
 
-                let options = options::executor_lz_receive_option(env, 200000, 0);
-                Self::__lz_send(
+                // Send the response message
+                let options = options::executor_lz_receive_option(env, 200000, 10);
+                Self::lz_send(
                     env,
                     &contract_address,
-                    src_eid,
-                    &codec::encode(env, MsgType::Vanilla, Self::eid(env)),
+                    origin.src_eid,
+                    &codec::encode_with_value(env, MsgType::Vanilla, Self::eid(env), 10),
                     &options,
                     &MessagingFee { native_fee: value, zro_fee: 0 },
                     &contract_address,
                 );
             }
-            _ => panic_with_error!(env, CounterError::InvalidMsgType),
+        }
+    }
+}
+
+// ============================================================================================
+// ILayerZeroComposer implementation
+// ============================================================================================
+
+#[contract_impl]
+impl ILayerZeroComposer for Counter {
+    fn lz_compose(
+        env: &Env,
+        executor: &Address,
+        from: &Address,
+        guid: &BytesN<32>,
+        index: u32,
+        message: &Bytes,
+        _extra_data: &Bytes,
+        value: i128,
+    ) {
+        executor.require_auth();
+
+        let msg_type = codec::msg_type(message);
+        if msg_type != MsgType::Composed && msg_type != MsgType::ComposedABA {
+            panic_with_error!(env, CounterError::InvalidMsgType);
+        }
+
+        let curr_address = env.current_contract_address();
+        let endpoint_address = Self::endpoint(env);
+
+        // Transfer value from executor to current contract
+        if value > 0 {
+            let native_token = LayerZeroEndpointV2Client::new(env, &endpoint_address).native_token();
+            TokenClient::new(env, &native_token).transfer_from(executor, executor, &curr_address, &value);
+        }
+        // Assert the value is sufficient
+        let expected_msg_value = codec::value(env, message);
+        assert_with_error!(env, value >= expected_msg_value, CounterError::InsufficientValue);
+
+        // Clear the compose message
+        MessagingComposerClient::new(env, &endpoint_address).clear_compose(&curr_address, from, guid, &index, message);
+
+        // Increment the composed count
+        CounterStorage::set_composed_count(env, &(Self::composed_count(env) + 1));
+
+        // Handle ComposedABA: send response message back to source
+        if msg_type == MsgType::ComposedABA {
+            let src_eid = codec::src_eid(message);
+
+            // Increment the outbound count
+            CounterStorage::set_outbound_count(env, src_eid, &(Self::outbound_count(env, src_eid) + 1));
+
+            // Send the response message
+            Self::lz_send(
+                env,
+                &curr_address,
+                src_eid,
+                &codec::encode(env, MsgType::Vanilla, Self::eid(env)),
+                &options::executor_lz_receive_option(env, 200000, 0),
+                &MessagingFee { native_fee: value, zro_fee: 0 },
+                &curr_address,
+            );
         }
     }
 }