@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

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

@@ -1,41 +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]
-        #[common_macros::ownable]
-        #item_struct
-
-        #manual_impl
-    }
-}

package/contracts/oapps/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/oapps/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/oapps/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/oapps/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
-    }
-}

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

@@ -1,107 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::Ident;
-use syn::{
-    parse::{Parse, ParseStream},
-    punctuated::Punctuated,
-    Error, ItemStruct, Token,
-};
-
-/// Configuration for which OApp trait implementations should be manually provided by the user.
-///
-/// This struct is parsed from the `#[oapp_manual_impl(...)]` attribute and controls
-/// which default trait implementations are generated by the macros.
-///
-/// # Fields
-/// * `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`
-///
-/// # 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`, `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)?;
-
-        let mut cfg = ManualImplConfig::default();
-
-        for ident in idents {
-            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`, `receiver`, `options_type3`",
-                    ));
-                }
-            }
-        }
-
-        Ok(cfg)
-    }
-}
-
-impl Parse for ManualImplConfig {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        ManualImplConfig::from_attr(input)
-    }
-}
-
-/// Parses a struct definition and extracts manual implementation configuration.
-///
-/// This function is used by all OApp macros to:
-/// 1. Parse the annotated item as a struct
-/// 2. Extract the struct name
-/// 3. Parse any `#[oapp_manual_impl(...)]` attributes to determine configuration
-///
-/// # Returns
-/// A tuple containing:
-/// * The struct identifier
-/// * The complete struct definition
-/// * The manual implementation configuration
-///
-/// # Errors
-/// Returns a compile error if:
-/// * The item is not a struct
-/// * The `#[oapp_manual_impl(...)]` attribute has invalid syntax
-pub fn parse_struct(item: TokenStream) -> Result<(Ident, ItemStruct, ManualImplConfig), TokenStream> {
-    let item_struct = syn::parse::<ItemStruct>(item).map_err(|e| e.to_compile_error())?;
-    let name = item_struct.ident.clone();
-
-    let mut cfg = ManualImplConfig::default();
-    // TODO: match at most once oapp_manual_impl attribute
-    for attr in item_struct.attrs.iter() {
-        if attr.path().is_ident("oapp_manual_impl") {
-            match attr.parse_args::<ManualImplConfig>() {
-                Ok(parsed) => {
-                    cfg = parsed;
-                }
-                Err(e) => {
-                    return Err(e.to_compile_error().into());
-                }
-            }
-            break;
-        }
-    }
-
-    Ok((name, item_struct, cfg))
-}

package/contracts/oapps/oft/src/constants.rs

@@ -1,5 +0,0 @@
-/// Message type for simple OFT send
-pub const SEND: u32 = 1;
-
-/// Message type for OFT send with compose functionality
-pub const SEND_AND_CALL: u32 = 2;

package/contracts/oapps/oft/src/default_oft_impl.rs

@@ -1,152 +0,0 @@
-//! Default OFT implementations.
-//!
-//! This module provides default standalone functions for common OFT operations that can be
-//! reused by trait implementations.
-
-use crate::{
-    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec::OFTMessage},
-    constants,
-    errors::OFTError,
-    events,
-    events::OFTSent,
-    storage::OFTStorage,
-    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
-    utils::{address_to_bytes32, remove_dust, resolve_address, to_ld, to_sd},
-};
-use endpoint_v2::{MessagingComposerClient, MessagingFee, MessagingReceipt, Origin};
-use oapp::oapp_options_type3::OAppOptionsType3;
-use soroban_sdk::{assert_with_error, vec, Address, Bytes, BytesN, Env, Vec};
-
-/// Calculates debit amounts without executing (view function).
-pub fn default_debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, _dst_eid: u32) -> OFTReceipt {
-    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
-    let amount_sent_ld = remove_dust(amount_ld, conversion_rate);
-    let amount_received_ld = amount_sent_ld;
-
-    assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
-
-    OFTReceipt { amount_sent_ld, amount_received_ld }
-}
-
-/// Builds OFT message and combines options for cross-chain transfer.
-pub fn default_build_msg_and_options<T>(
-    env: &Env,
-    sender: &Address,
-    send_param: &SendParam,
-    amount_ld: i128,
-) -> (Bytes, Bytes)
-where
-    T: OAppOptionsType3,
-{
-    let has_compose = !send_param.compose_msg.is_empty();
-    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
-    let msg = OFTMessage {
-        send_to: send_param.to.clone(),
-        amount_sd: to_sd(env, amount_ld, conversion_rate),
-        compose_from: if has_compose { Some(address_to_bytes32(sender)) } else { None },
-        compose_msg: if has_compose { Some(send_param.compose_msg.clone()) } else { None },
-    };
-    let (msg, _) = msg.encode(env);
-    let msg_type = if has_compose { constants::SEND_AND_CALL } else { constants::SEND };
-
-    (msg, T::combine_options(env, send_param.dst_eid, msg_type, &send_param.extra_options))
-}
-
-/// Handles OFT receive logic.
-pub fn default_lz_receive<T>(
-    env: &Env,
-    _executor: &Address,
-    origin: &Origin,
-    guid: &BytesN<32>,
-    message: &Bytes,
-    _extra_data: &Bytes,
-    _value: i128,
-) where
-    T: crate::oft::OFTInternal,
-{
-    let oft_msg = OFTMessage::decode(message);
-    let send_to = resolve_address(env, &oft_msg.send_to);
-
-    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
-    let amount_received_ld = T::__credit(env, &send_to, to_ld(oft_msg.amount_sd, conversion_rate), origin.src_eid);
-
-    if oft_msg.is_composed() {
-        let compose_msg = OFTComposeMsg {
-            nonce: origin.nonce,
-            src_eid: origin.src_eid,
-            amount_ld: amount_received_ld,
-            compose_from: oft_msg.compose_from.unwrap(),
-            compose_msg: oft_msg.compose_msg.unwrap(),
-        }
-        .encode(env);
-
-        let endpoint = MessagingComposerClient::new(env, &T::endpoint(env));
-        endpoint.send_compose(&env.current_contract_address(), &send_to, guid, &0, &compose_msg);
-    }
-
-    events::OFTReceived { guid: guid.clone(), src_eid: origin.src_eid, to: send_to, amount_received_ld }.publish(env);
-}
-
-/// Quotes an OFT transfer without executing.
-/// Returns (OFTLimit, fee details, receipt with estimated amounts).
-pub fn default_quote_oft<T>(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt)
-where
-    T: crate::oft::OFTInternal,
-{
-    let oft_receipt = T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
-    let oft_fee_details = if oft_receipt.amount_sent_ld > oft_receipt.amount_received_ld {
-        vec![
-            env,
-            OFTFeeDetail {
-                fee_amount_ld: oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld,
-                description: Bytes::from_array(env, b"OFT Fee"),
-            },
-        ]
-    } else {
-        vec![env]
-    };
-    (OFTLimit { min_amount_ld: 0, max_amount_ld: i128::MAX }, oft_fee_details, oft_receipt)
-}
-
-/// Quotes a send operation including LayerZero messaging fees.
-pub fn default_quote_send<T>(env: &Env, sender: &Address, send_param: &SendParam, pay_in_zro: bool) -> MessagingFee
-where
-    T: crate::oft::OFT,
-{
-    let OFTReceipt { amount_received_ld, .. } =
-        T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
-
-    let (msg, options) = default_build_msg_and_options::<T>(env, sender, send_param, amount_received_ld);
-    T::lz_quote(env, send_param.dst_eid, &msg, &options, pay_in_zro)
-}
-
-/// Sends tokens cross-chain to another endpoint.
-/// Sender must be authenticated. Returns (MessagingReceipt, OFTReceipt).
-pub fn default_send<T>(
-    env: &Env,
-    sender: &Address,
-    send_param: &SendParam,
-    fee: &MessagingFee,
-    refund_address: &Address,
-) -> (MessagingReceipt, OFTReceipt)
-where
-    T: crate::oft::OFT,
-{
-    sender.require_auth();
-
-    let oft_receipt = T::__debit(env, sender, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
-
-    let (msg, options) = default_build_msg_and_options::<T>(env, sender, send_param, oft_receipt.amount_received_ld);
-    let msg_receipt = T::lz_send(env, sender, send_param.dst_eid, &msg, &options, fee, refund_address);
-
-    OFTSent {
-        guid: msg_receipt.guid.clone(),
-        dst_eid: send_param.dst_eid,
-        from: sender.clone(),
-        amount_sent_ld: oft_receipt.amount_sent_ld,
-        amount_received_ld: oft_receipt.amount_received_ld,
-    }
-    .publish(env);
-
-    (msg_receipt, oft_receipt)
-}

package/contracts/oapps/oft/src/errors.rs

@@ -1,8 +0,0 @@
-use common_macros::contract_error;
-
-#[contract_error]
-pub enum OFTError {
-    InvalidLocalDecimals = 2100,
-    Overflow,
-    SlippageExceeded,
-}

package/contracts/oapps/oft/src/interfaces/mint_burn_token.rs

@@ -1,23 +0,0 @@
-use soroban_sdk::{contractclient, Address, Env};
-
-/// Contract interface for mint and burn token operations.
-///
-/// This interface abstracts the token mint/burn functionality, allowing different
-/// token implementations (e.g., StellarAssetContract, custom tokens) to be used
-/// with the MintBurn OFT.
-#[contractclient(name = "MintBurnTokenClient")]
-pub trait MintBurnToken {
-    /// Mints tokens to the specified address.
-    ///
-    /// # Parameters
-    /// * `to` - The address to mint tokens to
-    /// * `amount` - The amount of tokens to mint (must be non-negative)
-    fn mint(env: Env, to: Address, amount: i128);
-
-    /// Burns tokens from the specified address.
-    ///
-    /// # Parameters
-    /// * `from` - The address to burn tokens from
-    /// * `amount` - The amount of tokens to burn (must be non-negative)
-    fn burn(env: Env, from: Address, amount: i128);
-}

package/contracts/oapps/oft/src/interfaces/mod.rs

@@ -1,3 +0,0 @@
-mod mint_burn_token;
-
-pub use mint_burn_token::*;

package/contracts/oapps/oft/src/tests/extensions/mod.rs

@@ -1,11 +0,0 @@
-//! Extension tests module.
-//!
-//! This module contains tests for OFT extensions (pausable, oft_fee, rate_limiter).
-
-pub mod setup;
-pub mod test_oft_fee;
-pub mod test_pausable;
-pub mod test_rate_limiter;
-
-// Re-export commonly used items for convenience
-pub use setup::{ExtensiveOFT, ExtensiveOFTClient, ExtensiveOFTTestSetup};