@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.20

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

@@ -1,201 +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},
-    errors::OFTError,
-    events::{self, OFTSent},
-    oft::{OFTInternal, OFT},
-    storage::OFTStorage,
-    types::{self, OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
-    utils,
-};
-use ::utils::{option_ext::OptionExt, ownable::OwnableInitializer};
-use endpoint_v2::{MessagingComposerClient, MessagingFee, MessagingReceipt, Origin};
-use oapp::{oapp_core::initialize_oapp, oapp_options_type3::OAppOptionsType3};
-use soroban_sdk::{assert_with_error, token::TokenClient, vec, Address, Bytes, BytesN, Env, Vec};
-
-/// Initializes the OFT contract with token, endpoint, and decimal configuration.
-/// The `shared_decimals` must be <= token's local decimals.
-pub fn initialize_oft<T: OFT + OwnableInitializer>(
-    env: &Env,
-    owner: &Address,
-    token: &Address,
-    endpoint: &Address,
-    delegate: &Option<Address>,
-    shared_decimals: u32,
-) {
-    // Initialize OApp (includes owner initialization)
-    initialize_oapp::<T>(env, owner, endpoint, delegate);
-
-    let local_decimals = TokenClient::new(env, token).decimals();
-    assert_with_error!(env, local_decimals >= shared_decimals, OFTError::InvalidLocalDecimals);
-
-    // Initialize OFT storage
-    OFTStorage::set_token(env, token);
-    OFTStorage::set_decimal_conversion_rate(env, &10_i128.pow(local_decimals - shared_decimals));
-}
-
-/// Simulates a debit operation without executing, used for quoting.
-///
-/// # Arguments
-/// * `amount_ld` - The amount of tokens to send in local decimals
-/// * `min_amount_ld` - The minimum amount to send in local decimals (slippage protection)
-/// * `dst_eid` - The destination chain ID (unused in default implementation)
-///
-/// # Returns
-/// `OFTReceipt` containing the amount sent and amount received after dust removal
-pub fn debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, _dst_eid: u32) -> OFTReceipt {
-    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap_or_panic(env, OFTError::NotInitialized);
-    let amount_sent_ld = utils::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 the OFT message payload and combines enforced options for cross-chain transfer.
-///
-/// # Arguments
-/// * `from` - The address initiating the transfer
-/// * `send_param` - The send parameters including destination, recipient, and options
-/// * `receive_amount_ld` - The amount to be received in local decimals (after dust removal)
-///
-/// # Returns
-/// A tuple of (encoded message, combined options)
-pub fn build_msg_and_options<T: OAppOptionsType3>(
-    env: &Env,
-    from: &Address,
-    send_param: &SendParam,
-    receive_amount_ld: i128,
-) -> (Bytes, Bytes) {
-    let has_compose = !send_param.compose_msg.is_empty();
-    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap_or_panic(env, OFTError::NotInitialized);
-    let (msg, _) = OFTMessage {
-        send_to: send_param.to.clone(),
-        amount_sd: utils::to_sd(env, receive_amount_ld, conversion_rate),
-        compose_from: if has_compose { Some(utils::address_to_bytes32(from)) } else { None },
-        compose_msg: if has_compose { Some(send_param.compose_msg.clone()) } else { None },
-    }
-    .encode(env);
-    let msg_type = if has_compose { types::SEND_AND_CALL } else { types::SEND };
-
-    (msg, T::combine_options(env, send_param.dst_eid, msg_type, &send_param.extra_options))
-}
-
-/// Quotes an OFT transfer without executing.
-///
-/// # Arguments
-/// * `send_param` - The send parameters to quote
-///
-/// # Returns
-/// A tuple of (transfer limits, fee details, estimated receipt)
-pub fn quote_oft<T: OFTInternal>(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
-    let limit = OFTLimit { min_amount_ld: 0, max_amount_ld: i128::MAX }; // No limits in default implementation
-    let fee_details = vec![env]; // No fee details in default implementation
-    let oft_receipt = T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
-    (limit, fee_details, oft_receipt)
-}
-
-/// Quotes the LayerZero messaging fee for a send operation.
-///
-/// # Arguments
-/// * `from` - The address initiating the transfer
-/// * `send_param` - The send parameters to quote
-/// * `pay_in_zro` - Whether to pay the fee in ZRO token
-///
-/// # Returns
-/// The messaging fee required for the transfer
-pub fn quote_send<T: OFT>(env: &Env, from: &Address, send_param: &SendParam, pay_in_zro: bool) -> MessagingFee {
-    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) = build_msg_and_options::<T>(env, from, send_param, amount_received_ld);
-    T::__quote(env, send_param.dst_eid, &msg, &options, pay_in_zro)
-}
-
-/// Executes a cross-chain token transfer via LayerZero.
-///
-/// Debits tokens from the `from` address, builds the message, and sends via the endpoint.
-/// The `from` address must be authenticated.
-///
-/// # Arguments
-/// * `from` - The address sending tokens (must authorize)
-/// * `send_param` - The send parameters (destination, recipient, amount, options)
-/// * `fee` - The messaging fee to pay
-/// * `refund_address` - The address to refund excess fees to
-///
-/// # Returns
-/// A tuple of (messaging receipt, OFT receipt with amounts)
-pub fn send<T: OFT>(
-    env: &Env,
-    from: &Address,
-    send_param: &SendParam,
-    fee: &MessagingFee,
-    refund_address: &Address,
-) -> (MessagingReceipt, OFTReceipt) {
-    from.require_auth();
-
-    let oft_receipt = T::__debit(env, from, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
-
-    let (msg, options) = build_msg_and_options::<T>(env, from, send_param, oft_receipt.amount_received_ld);
-    let msg_receipt = T::__lz_send(env, send_param.dst_eid, &msg, &options, from, fee, refund_address);
-
-    OFTSent {
-        guid: msg_receipt.guid.clone(),
-        dst_eid: send_param.dst_eid,
-        from: from.clone(),
-        amount_sent_ld: oft_receipt.amount_sent_ld,
-        amount_received_ld: oft_receipt.amount_received_ld,
-    }
-    .publish(env);
-
-    (msg_receipt, oft_receipt)
-}
-
-/// Handles incoming cross-chain OFT transfer from LayerZero endpoint.
-///
-/// Credits tokens to the recipient and optionally queues a compose message.
-///
-/// # Arguments
-/// * `executor` - The address of the executor handling the message (unused in default implementation)
-/// * `origin` - The origin information (source chain, sender, nonce)
-/// * `guid` - The unique message identifier
-/// * `message` - The encoded OFT message payload
-/// * `extra_data` - Additional data (unused in default implementation)
-/// * `value` - The native token value sent with the message (unused in default implementation)
-pub fn lz_receive<T: OFTInternal>(
-    env: &Env,
-    _executor: &Address,
-    origin: &Origin,
-    guid: &BytesN<32>,
-    message: &Bytes,
-    _extra_data: &Bytes,
-    _value: i128,
-) {
-    let oft_msg = OFTMessage::decode(message);
-    let send_to = utils::resolve_address(env, &oft_msg.send_to);
-
-    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap_or_panic(env, OFTError::NotInitialized);
-    let amount_received_ld =
-        T::__credit(env, &send_to, utils::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_client = MessagingComposerClient::new(env, &T::endpoint(env));
-        endpoint_client.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);
-}

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};