@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.18

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/workers/dvn/src/interfaces/multisig.rs

@@ -1,56 +0,0 @@
-use soroban_sdk::{contractclient, BytesN, Env, Vec};
-
-/// Length of an ECDSA signature (64 bytes) plus recovery ID (1 byte).
-pub const SIGNATURE_LENGTH: usize = 65;
-
-/// Multisig interface for threshold-based signature verification.
-///
-/// Provides functionality to manage signers and verify that a sufficient
-/// number of valid signatures (meeting the threshold) have signed a message.
-#[contractclient(name = "MultiSigClient")]
-pub trait IMultisig {
-    /// Adds or removes a signer from the multisig.
-    ///
-    /// # Arguments
-    /// * `signer` - The 20-byte signer address (derived from secp256k1 public key)
-    /// * `active` - `true` to add, `false` to remove
-    fn set_signer(env: &Env, signer: &BytesN<20>, active: bool);
-
-    /// Returns all registered signers.
-    fn get_signers(env: &Env) -> Vec<BytesN<20>>;
-
-    /// Returns the total number of registered signers.
-    fn total_signers(env: &Env) -> u32;
-
-    /// Checks if an address is a registered signer.
-    fn is_signer(env: &Env, signer: &BytesN<20>) -> bool;
-
-    /// Returns the current signature threshold (quorum).
-    fn threshold(env: &Env) -> u32;
-
-    /// Sets the signature threshold (quorum).
-    ///
-    /// The threshold must be greater than 0 and not exceed total signers.
-    fn set_threshold(env: &Env, threshold: u32);
-
-    /// Verifies signatures against the configured threshold.
-    ///
-    /// # Arguments
-    /// * `hash` - The 32-byte message hash that was signed
-    /// * `signatures` - List of signatures to verify
-    ///
-    /// # Panics
-    /// If fewer than `threshold` valid signatures from registered signers are provided.
-    fn verify_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<SIGNATURE_LENGTH>>);
-
-    /// Verifies signatures against a custom threshold.
-    ///
-    /// # Arguments
-    /// * `hash` - The 32-byte message hash that was signed
-    /// * `signatures` - List of signatures to verify
-    /// * `threshold` - Custom threshold to use instead of the configured one
-    ///
-    /// # Panics
-    /// If fewer than `threshold` valid signatures from registered signers are provided.
-    fn verify_n_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<SIGNATURE_LENGTH>>, threshold: u32);
-}

package/contracts/workers/dvn/src/multisig.rs

@@ -1,157 +0,0 @@
-//! Multisig functionality for the DVN contract.
-//!
-//! Provides secp256k1-based multisig signature verification using Ethereum-style
-//! 20-byte addresses derived from recovered public keys.
-
-use super::*;
-
-use crate::{
-    errors::DvnError,
-    events::{SignerSet, ThresholdSet},
-    storage::DvnStorage,
-};
-use common_macros::only_owner;
-use soroban_sdk::assert_with_error;
-
-// ============================================================================
-// IMultisig Implementation
-// ============================================================================
-
-#[contract_impl]
-impl IMultisig for LzDVN {
-    /// Adds or removes a signer. Requires multisig approval.
-    #[only_owner]
-    fn set_signer(env: &Env, signer: &BytesN<20>, active: bool) {
-        if active {
-            Self::add_signer(env, signer);
-        } else {
-            Self::remove_signer(env, signer);
-        }
-    }
-
-    /// Updates the signature threshold. Requires multisig approval.
-    #[only_owner]
-    fn set_threshold(env: &Env, threshold: u32) {
-        assert_with_error!(env, threshold > 0, DvnError::ZeroThreshold);
-        assert_with_error!(env, Self::total_signers(env) >= threshold, DvnError::TotalSignersLessThanThreshold);
-
-        DvnStorage::set_threshold(env, &threshold);
-
-        ThresholdSet { threshold }.publish(env);
-    }
-
-    // ================================================================
-    // View Functions
-    // ================================================================
-
-    /// Returns the list of all registered signers.
-    fn get_signers(env: &Env) -> Vec<BytesN<20>> {
-        DvnStorage::signers(env)
-    }
-
-    /// Returns the total number of registered signers.
-    fn total_signers(env: &Env) -> u32 {
-        DvnStorage::signers(env).len()
-    }
-
-    /// Checks if an address is a registered signer.
-    fn is_signer(env: &Env, signer: &BytesN<20>) -> bool {
-        DvnStorage::signers(env).iter().any(|s| &s == signer)
-    }
-
-    /// Returns the current signature threshold.
-    fn threshold(env: &Env) -> u32 {
-        DvnStorage::threshold(env)
-    }
-
-    /// Verifies signatures against the current threshold.
-    fn verify_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<65>>) {
-        Self::verify_n_signatures(env, hash, signatures, Self::threshold(env));
-    }
-
-    /// Verifies that at least `threshold` valid signatures exist for the given hash.
-    ///
-    /// Signatures must be:
-    /// - From registered signers
-    /// - Sorted by signer address (ascending, no duplicates)
-    fn verify_n_signatures(env: &Env, hash: &BytesN<32>, signatures: &Vec<BytesN<65>>, threshold: u32) {
-        assert_with_error!(env, threshold > 0, DvnError::ZeroThreshold);
-        assert_with_error!(env, signatures.len() >= threshold, DvnError::SignatureError);
-
-        let mut last_signer: Option<BytesN<20>> = None;
-        signatures.iter().for_each(|signature| {
-            let signer = Self::recover_signer(env, hash, &signature);
-
-            // Signers must be strictly increasing (ensures no duplicates)
-            assert_with_error!(env, last_signer.as_ref().is_none_or(|last| &signer > last), DvnError::UnsortedSigners);
-            assert_with_error!(env, Self::is_signer(env, &signer), DvnError::SignerNotFound);
-
-            last_signer = Some(signer);
-        });
-    }
-}
-
-// ============================================================================
-// Internal Functions
-// ============================================================================
-
-impl LzDVN {
-    /// Initializes the multisig with a set of signers and threshold.
-    /// Called during contract construction.
-    pub(super) fn init_multisig(env: &Env, signers: &Vec<BytesN<20>>, threshold: u32) {
-        signers.iter().for_each(|signer| Self::add_signer(env, &signer));
-        Self::set_threshold(env, threshold);
-    }
-
-    /// Adds a new signer to the multisig.
-    ///
-    /// # Errors
-    /// - `InvalidSigner` if the signer is the zero address
-    /// - `SignerAlreadyExists` if the signer is already registered
-    fn add_signer(env: &Env, signer: &BytesN<20>) {
-        let zero_signer = BytesN::from_array(env, &[0u8; 20]);
-        assert_with_error!(env, signer != &zero_signer, DvnError::InvalidSigner);
-
-        let mut signers = Self::get_signers(env);
-        assert_with_error!(env, !signers.iter().any(|s| &s == signer), DvnError::SignerAlreadyExists);
-        signers.push_back(signer.clone());
-        DvnStorage::set_signers(env, &signers);
-
-        SignerSet { signer: signer.clone(), active: true }.publish(env);
-    }
-
-    /// Removes a signer from the multisig.
-    ///
-    /// # Errors
-    /// - `SignerNotFound` if the signer is not registered
-    /// - `TotalSignersLessThanThreshold` if removal would violate threshold constraint
-    fn remove_signer(env: &Env, signer: &BytesN<20>) {
-        let mut signers = Self::get_signers(env);
-        let index = signers.first_index_of(signer);
-        assert_with_error!(env, index.is_some(), DvnError::SignerNotFound);
-
-        signers.remove(index.unwrap());
-
-        // Ensure removal doesn't violate threshold constraint
-        assert_with_error!(env, signers.len() >= Self::threshold(env), DvnError::TotalSignersLessThanThreshold);
-        DvnStorage::set_signers(env, &signers);
-
-        SignerSet { signer: signer.clone(), active: false }.publish(env);
-    }
-
-    /// Recovers the Ethereum-style signer address from a secp256k1 signature.
-    ///
-    /// The signature format is 65 bytes: r (32) + s (32) + v (1).
-    /// Returns the last 20 bytes of keccak256(uncompressed_pubkey[1..65]).
-    fn recover_signer(env: &Env, digest: &BytesN<32>, signature: &BytesN<65>) -> BytesN<20> {
-        let sig_bytes: Bytes = signature.into();
-        let v = sig_bytes.get(64).unwrap();
-        let recovery_id = if (27..=30).contains(&v) { v - 27 } else { v };
-        let sig_rs: BytesN<64> = sig_bytes.slice(0..64).try_into().unwrap();
-
-        let public_key = env.crypto_hazmat().secp256k1_recover(digest, &sig_rs, recovery_id as u32);
-
-        // Derive Ethereum address: keccak256(pubkey[1..65])[12..32]
-        Bytes::from(env.crypto().keccak256(&Bytes::from(public_key).slice(1..65))).slice(12..32).try_into().unwrap()
-    }
-}