@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/message-libs/uln-302/src/uln302.rs

@@ -0,0 +1,117 @@
+use crate::{
+    errors::Uln302Error,
+    events::{
+        DVNFeePaid, DefaultExecutorConfigSet, DefaultUlnReceiveConfigSet, DefaultUlnSendConfigSet, ExecutorConfigSet,
+        ExecutorFeePaid, PayloadVerified, UlnReceiveConfigSet, UlnSendConfigSet,
+    },
+    interfaces::{
+        ExecutorConfig, IReceiveUln302, ISendUln302, OAppExecutorConfig, OAppUlnConfig, SetDefaultExecutorConfigParam,
+        SetDefaultUlnConfigParam, UlnConfig,
+    },
+    storage::UlnStorage,
+};
+use common_macros::{only_owner, ttl_configurable};
+use endpoint_v2::{
+    util, FeeRecipient, FeesAndPacket, IMessageLib, ISendLib, LayerZeroEndpointV2Client, MessageLibType,
+    MessageLibVersion, MessagingFee, Origin, OutboundPacket, SetConfigParam,
+};
+use message_lib_common::{
+    packet_codec_v1::{self, PacketHeader},
+    worker_options, LayerZeroDVNClient, LayerZeroExecutorClient, LayerZeroTreasuryClient,
+};
+use soroban_sdk::{
+    address_payload::AddressPayload,
+    assert_with_error, bytes, contract, contractimpl, panic_with_error, vec,
+    xdr::{FromXdr, ToXdr},
+    Address, Bytes, BytesN, Env, Map, Vec,
+};
+use utils::option_ext::OptionExt;
+
+pub const CONFIG_TYPE_EXECUTOR: u32 = 1;
+pub const CONFIG_TYPE_SEND_ULN: u32 = 2;
+pub const CONFIG_TYPE_RECEIVE_ULN: u32 = 3;
+
+#[contract]
+#[ttl_configurable]
+pub struct Uln302;
+
+#[contractimpl]
+impl Uln302 {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, treasury: &Address) {
+        Self::__init_owner(env, owner);
+        UlnStorage::set_endpoint(env, endpoint);
+        UlnStorage::set_treasury(env, treasury);
+    }
+
+    // === View Functions ===
+
+    /// Returns the LayerZero endpoint contract address.
+    pub fn endpoint(env: &Env) -> Address {
+        UlnStorage::endpoint(env).unwrap()
+    }
+}
+
+#[contractimpl]
+impl IMessageLib for Uln302 {
+    /// Sets OApp-specific configuration parameters for the message library.
+    ///
+    /// Called by the endpoint on behalf of the OApp to configure executor and ULN settings.
+    /// Supports three config types: EXECUTOR, SEND_ULN, and RECEIVE_ULN.
+    fn set_config(env: &Env, oapp: &Address, params: &Vec<SetConfigParam>) {
+        Self::endpoint(env).require_auth();
+
+        for param in params {
+            assert_with_error!(env, Self::is_supported_eid(env, param.eid), Uln302Error::UnsupportedEid);
+
+            match param.config_type {
+                CONFIG_TYPE_EXECUTOR => {
+                    Self::set_executor_config(env, oapp, param.eid, &parse_config(env, &param.config));
+                }
+                CONFIG_TYPE_SEND_ULN => {
+                    Self::set_send_uln_config(env, oapp, param.eid, &parse_config(env, &param.config));
+                }
+                CONFIG_TYPE_RECEIVE_ULN => {
+                    Self::set_receive_uln_config(env, oapp, param.eid, &parse_config(env, &param.config));
+                }
+                _ => panic_with_error!(env, Uln302Error::InvalidConfigType),
+            }
+        }
+    }
+
+    /// Returns the XDR-encoded effective configuration bytes.
+    fn get_config(env: &Env, eid: u32, oapp: &Address, config_type: u32) -> Bytes {
+        match config_type {
+            CONFIG_TYPE_EXECUTOR => Self::effective_executor_config(env, oapp, eid).to_xdr(env),
+            CONFIG_TYPE_SEND_ULN => Self::effective_send_uln_config(env, oapp, eid).to_xdr(env),
+            CONFIG_TYPE_RECEIVE_ULN => Self::effective_receive_uln_config(env, oapp, eid).to_xdr(env),
+            _ => panic_with_error!(env, Uln302Error::InvalidConfigType),
+        }
+    }
+
+    /// Returns true if the message library has default send and receive ULN configurations for the endpoint ID.
+    fn is_supported_eid(env: &Env, eid: u32) -> bool {
+        UlnStorage::has_default_send_uln_configs(env, eid) && UlnStorage::has_default_receive_uln_configs(env, eid)
+    }
+
+    /// Returns the version of the message library.
+    fn version(_env: &Env) -> MessageLibVersion {
+        MessageLibVersion { major: 3, minor: 0, endpoint_version: 2 }
+    }
+
+    /// Returns the type of the message library.
+    fn message_lib_type(_env: &Env) -> MessageLibType {
+        MessageLibType::SendAndReceive
+    }
+}
+
+// ================================================
+// Helper Functions
+// ================================================
+
+/// Parse a config from XDR bytes, panicking with InvalidConfig error if parsing fails
+fn parse_config<T: FromXdr>(env: &Env, config_bytes: &Bytes) -> T {
+    T::from_xdr(env, config_bytes).ok().unwrap_or_panic(env, Uln302Error::InvalidConfig)
+}
+
+include!("send.rs");
+include!("receive.rs");

package/contracts/oapp-macros/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "oapp-macros"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full", "extra-traits"] }
+
+[dev-dependencies]
+oapp = { workspace = true }
+soroban-sdk = { workspace = true, features = ["testutils"] }
+common-macros = { workspace = true }
+utils = { workspace = true }
+endpoint-v2 = { workspace = true , features = ["library"]}

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

@@ -0,0 +1,408 @@
+//! # OApp Procedural Macros
+//!
+//! This crate provides procedural macros for implementing LayerZero OApp (Omnichain Application)
+//! functionality on Soroban smart contracts. These macros simplify the process of creating
+//! cross-chain applications by automatically generating the necessary trait implementations.
+//!
+//! ## Overview
+//!
+//! The OApp framework consists of several core components:
+//!
+//! - **OAppCore**: Foundation for all OApp functionality, providing peer management and 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]`
+//! A convenience macro that combines Core + Sender + Receiver functionality. This is the most
+//! common choice for  cross-chain communication.
+//!
+//! ### `#[oapp_core]`
+//! Derives only the core OApp functionality (peer management, endpoint access).
+//!
+//! ### `#[oapp_sender]`
+//! Derives Core + Sender functionality for applications that only need to send messages.
+//!
+//! ### `#[oapp_receiver]`
+//! Derives Core + Receiver functionality for applications that only need to receive messages.
+//!
+//! ### `#[oapp_options_type3]`
+//! Derives the Options Type 3 functionality for managing enforced message options.
+//! Can be combined with other macros.
+//!
+//! ### `#[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, macros generate default trait implementations. Use `#[oapp_manual_impl(...)]`
+//! to customize specific behaviors:
+//!
+//! ```ignore
+//! #[oapp_core]
+//! #[oapp_manual_impl(core)]
+//! struct MyOApp;
+//!
+//! impl OAppCoreOverrides for MyOApp {
+//!     fn __oapp_version(_env: &Env) -> (u64, u64) {
+//!         (1, 1) // Custom version
+//!     }
+//! }
+//! ```
+//!
+//! Supported options:
+//! - `core` - Manually implement `OAppCoreOverrides`
+//! - `sender` - Manually implement `OAppSenderOverrides`
+//! - `options_type3` - Manually implement `OAppOptionsType3Overrides`
+//!
+//! **Note**: There is no `receiver` option because `OAppReceiverOverrides::__lz_receive`
+//! **must always** be manually implemented by the user to define custom message handling logic.
+//!
+//! ## Examples
+//!
+//! ### Full OApp with Default Implementations
+//!
+//! ```ignore
+//! use oapp_macros::oapp;
+//! use oapp::oapp_receiver::OAppReceiverOverrides;
+//!
+//! #[oapp]
+//! struct MyOApp;
+//!
+//! // Only __lz_receive must be implemented
+//! impl OAppReceiverOverrides for MyOApp {
+//!     fn __lz_receive(
+//!         env: &Env,
+//!         executor: &Address,
+//!         origin: &Origin,
+//!         guid: &BytesN<32>,
+//!         message: &Bytes,
+//!         extra_data: &Bytes,
+//!         value: i128,
+//!     ) {
+//!         // Your custom message handling logic
+//!     }
+//! }
+//! ```
+//!
+//! ### Full OApp with Custom Core Implementation
+//!
+//! ```ignore
+//! #[oapp]
+//! #[oapp_manual_impl(core)]
+//! struct MyCustomOApp;
+//!
+//! impl OAppCoreOverrides for MyCustomOApp {
+//!     fn __oapp_version(_env: &Env) -> (u64, u64) {
+//!         (2, 1) // Custom version
+//!     }
+//!     // Other methods use defaults
+//! }
+//!
+//! impl OAppReceiverOverrides for MyCustomOApp {
+//!     fn __lz_receive(...) { /* ... */ }
+//! }
+//! ```
+//!
+//! ### Sender-Only OApp
+//!
+//! ```ignore
+//! #[oapp_sender]
+//! struct MySenderOApp;
+//! // Uses all defaults, no manual implementation needed
+//! ```
+//!
+//! ### OApp with Options Type 3
+//!
+//! ```ignore
+//! #[oapp]
+//! #[oapp_options_type3]
+//! struct MyOAppWithOptions;
+//!
+//! impl OAppReceiverOverrides for MyOAppWithOptions {
+//!     fn __lz_receive(...) { /* ... */ }
+//! }
+//! // OAppOptionsType3Overrides uses defaults
+//! ```
+
+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 OAppCore implementation, providing the foundation for OApp functionality.
+///
+/// This macro generates:
+/// - `#[soroban_sdk::contract]` attribute
+/// - `#[common_macros::ownable]` attribute for ownership management
+/// - Implementation of `OAppCore` trait with methods delegating to `OAppCoreOverrides`
+///
+/// By default, an empty `OAppCoreOverrides` implementation is generated. Use
+/// `#[oapp_manual_impl(core)]` to provide custom implementations.
+///
+/// # Example
+///
+/// ```ignore
+/// #[oapp_core]
+/// struct MyOApp;
+/// // Uses default OAppCore implementation
+/// ```
+///
+/// # Example with Manual Implementation
+///
+/// ```ignore
+/// #[oapp_core]
+/// #[oapp_manual_impl(core)]
+/// struct MyCustomOApp;
+///
+/// impl OAppCoreOverrides for MyCustomOApp {
+///     fn __oapp_version(_env: &Env) -> (u64, u64) {
+///         (1, 2)
+///     }
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn oapp_core(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let (name, item, disable_config) = match parse_struct(item) {
+        Ok(result) => result,
+        Err(e) => return e,
+    };
+    oapp_core::generate_impl(&name, item, disable_config.core).into()
+}
+
+/// Derives OAppSender implementation, providing cross-chain message sending capabilities.
+///
+/// This macro automatically includes `#[oapp_core]` functionality, generating both
+/// Core and Sender implementations. By default, an empty `OAppSenderOverrides`
+/// implementation is generated. Use `#[oapp_manual_impl(sender)]` or
+/// `#[oapp_manual_impl(core, sender)]` for custom implementations.
+///
+/// # Example
+///
+/// ```ignore
+/// #[oapp_sender]
+/// struct MySender;
+/// // Can now send cross-chain messages using default implementations
+/// ```
+///
+/// # Example with Manual Sender Implementation
+///
+/// ```ignore
+/// #[oapp_sender]
+/// #[oapp_manual_impl(sender)]
+/// struct MyCustomSender;
+///
+/// impl OAppSenderOverrides for MyCustomSender {
+///     // Custom sender logic
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn oapp_sender(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let (name, item, disable_config) = match parse_struct(item) {
+        Ok(result) => result,
+        Err(e) => return e,
+    };
+    oapp_sender::generate_impl_with_core(&name, item, disable_config).into()
+}
+
+/// Derives OAppReceiver implementation, providing receive capabilities
+///
+/// **Important**: Unlike other OApp macros, this macro does NOT support `manual_impl`
+/// configuration because the `__lz_receive` method in `OAppReceiverOverrides` trait
+/// has no default implementation. Users **MUST** always manually implement
+/// `OAppReceiverOverrides::__lz_receive` to define their custom message handling logic.
+///
+/// # Example
+/// ```ignore
+/// #[oapp_receiver]
+/// struct MyReceiver;
+///
+/// impl OAppReceiverOverrides for MyReceiver {
+///     fn __lz_receive(
+///         env: &Env,
+///         executor: &Address,
+///         origin: &Origin,
+///         guid: &BytesN<32>,
+///         message: &Bytes,
+///         extra_data: &Bytes,
+///         value: i128,
+///     ) {
+///         // Your custom message handling logic here
+///     }
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn oapp_receiver(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let (name, item, disable_config) = match parse_struct(item) {
+        Ok(result) => result,
+        Err(e) => return e,
+    };
+    oapp_receiver::generate_impl_with_core(&name, item, disable_config).into()
+}
+
+/// Derives a complete OApp implementation with Core + Sender + Receiver functionality.
+///
+/// This is a convenience macro that combines all three core OApp components. It's the
+/// most common choice for applications that need full bidirectional cross-chain communication.
+///
+/// **Important**: You **must** always implement `OAppReceiverOverrides::__lz_receive` to
+/// define your custom message handling logic, as it has no default implementation.
+///
+/// # Example
+///
+/// ```ignore
+/// #[oapp]
+/// struct MyFullOApp;
+///
+/// impl OAppReceiverOverrides for MyFullOApp {
+///     fn __lz_receive(
+///         env: &Env,
+///         executor: &Address,
+///         origin: &Origin,
+///         guid: &BytesN<32>,
+///         message: &Bytes,
+///         extra_data: &Bytes,
+///         value: i128,
+///     ) {
+///         // Your message handling logic here
+///     }
+/// }
+/// ```
+///
+/// # Example with Manual Core Implementation
+///
+/// ```ignore
+/// #[oapp]
+/// #[oapp_manual_impl(core)]
+/// struct MyCustomFullOApp;
+///
+/// impl OAppCoreOverrides for MyCustomFullOApp {
+///     fn __oapp_version(_env: &Env) -> (u64, u64) {
+///         (2, 0)
+///     }
+/// }
+///
+/// impl OAppReceiverOverrides for MyCustomFullOApp {
+///     fn __lz_receive(...) { /* ... */ }
+/// }
+/// ```
+#[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()
+}
+
+/// Derives OAppOptionsType3 implementation for managing enforced message options.
+///
+/// This macro provides fine-grained control over message execution parameters per endpoint
+/// and message type. Unlike other OApp macros, this does **not** automatically add the
+/// `#[soroban_sdk::contract]` attribute, so it can be used standalone or combined with
+/// other OApp macros.
+///
+/// By default, an empty `OAppOptionsType3Overrides` implementation is generated. Use
+/// `#[oapp_manual_impl(options_type3)]` for custom implementations.
+///
+/// # Example - Standalone
+///
+/// ```ignore
+/// #[contract]
+/// #[ownable]
+/// #[oapp_options_type3]
+/// struct MyOptions;
+/// // Uses default options implementation
+/// ```
+///
+/// # Example - Combined with Full OApp
+///
+/// ```ignore
+/// #[oapp]
+/// #[oapp_options_type3]
+/// struct MyOAppWithOptions;
+///
+/// impl OAppReceiverOverrides for MyOAppWithOptions {
+///     fn __lz_receive(...) { /* ... */ }
+/// }
+/// ```
+///
+/// # Example with Manual Implementation
+///
+/// ```ignore
+/// #[contract]
+/// #[ownable]
+/// #[oapp_options_type3]
+/// #[oapp_manual_impl(options_type3)]
+/// struct MyCustomOptions;
+///
+/// impl OAppOptionsType3Overrides for MyCustomOptions {
+///     fn __enforced_options(env: &Env, eid: u32, msg_type: u32) -> Bytes {
+///         // Custom enforced options logic
+///     }
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn oapp_options_type3(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let (name, item, disable_config) = match parse_struct(item) {
+        Ok(result) => result,
+        Err(e) => return e,
+    };
+    oapp_options_type3::generate_impl(&name, item, disable_config.options_type3).into()
+}
+
+/// Marker attribute to specify which trait implementations should be manually provided.
+///
+/// Use this attribute together with OApp macros to indicate that you will provide
+/// custom implementations instead of using the default ones.
+///
+/// # Supported Options
+///
+/// - `core` - Manually implement `OAppCoreOverrides`
+/// - `sender` - Manually implement `OAppSenderOverrides`
+/// - `options_type3` - Manually implement `OAppOptionsType3Overrides`
+///
+/// **Note**: There is no `receiver` option because `OAppReceiverOverrides::__lz_receive`
+/// must **always** be manually implemented (it has no default implementation).
+///
+/// # Examples
+///
+/// ```ignore
+/// // Manual core implementation
+/// #[oapp_core]
+/// #[oapp_manual_impl(core)]
+/// struct MyOApp;
+///
+/// impl OAppCoreOverrides for MyOApp {
+///     fn __oapp_version(_env: &Env) -> (u64, u64) {
+///         (1, 1)
+///     }
+/// }
+/// ```
+///
+/// ```ignore
+/// // Multiple manual implementations
+/// #[oapp]
+/// #[oapp_options_type3]
+/// #[oapp_manual_impl(core, sender, options_type3)]
+/// struct MyFullCustomOApp;
+///
+/// impl OAppCoreOverrides for MyFullCustomOApp { /* ... */ }
+/// impl OAppSenderOverrides for MyFullCustomOApp { /* ... */ }
+/// impl OAppReceiverOverrides for MyFullCustomOApp {
+///     fn __lz_receive(...) { /* required */ }
+/// }
+/// impl OAppOptionsType3Overrides for MyFullCustomOApp { /* ... */ }
+/// ```
+#[proc_macro_attribute]
+pub fn oapp_manual_impl(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    item
+}

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

@@ -0,0 +1,49 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Ident, ItemStruct};
+
+pub fn generate_impl(name: &Ident, item_struct: ItemStruct, manual_impl_core: bool) -> TokenStream {
+    let manual_impl = (!manual_impl_core).then(|| {
+        quote! {
+            use oapp::oapp_core::OAppCoreOverrides as _;
+
+            impl oapp::oapp_core::OAppCoreOverrides for #name {}
+        }
+    });
+
+    quote! {
+        use oapp::oapp_core::OAppCore as _;
+
+        #[soroban_sdk::contract]
+        #[common_macros::ownable]
+        #item_struct
+
+        #[soroban_sdk::contractimpl]
+        impl oapp::oapp_core::OAppCore for #name {
+            #[common_macros::only_owner]
+            fn set_peer(env: &soroban_sdk::Env, eid: u32, peer: &Option<soroban_sdk::BytesN<32>>) {
+                <Self as oapp::oapp_core::OAppCoreOverrides>::__set_peer(env, eid, peer)
+            }
+
+            #[common_macros::only_owner]
+            fn set_delegate(env: &soroban_sdk::Env, delegate: &Option<soroban_sdk::Address>) {
+                <Self as oapp::oapp_core::OAppCoreOverrides>::__set_delegate(env, delegate)
+            }
+
+            fn peer(env: &soroban_sdk::Env, eid: u32) -> Option<soroban_sdk::BytesN<32>> {
+                <Self as oapp::oapp_core::OAppCoreOverrides>::__peer(env, eid)
+            }
+
+            fn oapp_version(env: &soroban_sdk::Env) -> (u64, u64) {
+                <Self as oapp::oapp_core::OAppCoreOverrides>::__oapp_version(env)
+            }
+
+            fn endpoint(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+                <Self as oapp::oapp_core::OAppCoreOverrides>::__endpoint(env)
+            }
+
+        }
+
+        #manual_impl
+    }
+}

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

@@ -0,0 +1,15 @@
+use crate::{oapp_core, oapp_receiver, oapp_sender, util::ManualImplConfig};
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Ident, ItemStruct};
+
+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);
+    quote! {
+        #core_impl
+        #sender_impl
+        #receiver_impl
+    }
+}

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

@@ -0,0 +1,46 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Ident, ItemStruct};
+
+pub fn generate_impl(name: &Ident, item_struct: ItemStruct, manual_impl_options_type3: bool) -> TokenStream {
+    let manual_impl = (!manual_impl_options_type3).then(|| {
+        quote! {
+            use oapp::oapp_options_type3::OAppOptionsType3Overrides as _;
+
+            impl oapp::oapp_options_type3::OAppOptionsType3Overrides for #name {}
+        }
+    });
+
+    quote! {
+        use oapp::oapp_options_type3::OAppOptionsType3 as _;
+
+        #item_struct
+
+        #[soroban_sdk::contractimpl]
+        impl oapp::oapp_options_type3::OAppOptionsType3 for #name
+        {
+            #[common_macros::only_owner]
+            fn set_enforced_options(
+                env: &soroban_sdk::Env,
+                options: soroban_sdk::Vec<oapp::oapp_options_type3::EnforcedOptionParam>,
+            ) {
+                <Self as oapp::oapp_options_type3::OAppOptionsType3Overrides>::__set_enforced_options(env, options)
+            }
+
+            fn combine_options(
+                env: &soroban_sdk::Env,
+                eid: u32,
+                msg_type: u32,
+                extra_options: &soroban_sdk::Bytes,
+            ) -> soroban_sdk::Bytes {
+                <Self as oapp::oapp_options_type3::OAppOptionsType3Overrides>::__combine_options(env, eid, msg_type, extra_options)
+            }
+
+            fn enforced_options(env: &soroban_sdk::Env, eid: u32, msg_type: u32) -> soroban_sdk::Bytes {
+                <Self as oapp::oapp_options_type3::OAppOptionsType3Overrides>::__enforced_options(env, eid, msg_type)
+            }
+        }
+
+        #manual_impl
+    }
+}