@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.18

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

@@ -8,7 +8,8 @@
 //!
 //! ```ignore
 //! use oapp_macros::{oapp, oapp_options_type3};
-//! use oft::oft::{oft_initialize, OFTInternal, OFT};
+//! use oft::oft::{OFTInternal, OFT};
+//! use oft::initialize_oft;
 //!
 //! #[oapp]
 //! pub struct MyOFT;
@@ -16,7 +17,7 @@
 //! #[contractimpl]
 //! impl MyOFT {
 //!     pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
-//!         oft_initialize::<Self>(env, owner, token, endpoint, delegate)
+//!         initialize_oft::<Self>(env, owner, token, endpoint, delegate)
 //!     }
 //! }
 //!
@@ -43,41 +44,13 @@
 // inside this crate and in external crates implementing the OFT trait.
 extern crate self as oft;
 
-use crate::{errors::OFTError, storage::OFTStorage, types::OFTReceipt};
-use endpoint_v2::Origin;
+use crate::{oft_impl, storage::OFTStorage, types::OFTReceipt};
+use common_macros::contract_trait;
 use oapp::{
-    oapp_core::{oapp_initialize, OAppCore},
-    oapp_options_type3::OAppOptionsType3,
-    oapp_receiver::OAppReceiver,
-    oapp_sender::OAppSender,
+    oapp_core::OAppCore, oapp_options_type3::OAppOptionsType3, oapp_receiver::OAppReceiver,
+    oapp_sender::OAppSenderInternal,
 };
-use soroban_sdk::{assert_with_error, contracttrait, token::TokenClient, Address, Bytes, BytesN, Env};
-use utils::ownable::OwnableInitializer;
-
-// =====================================================
-// OFT Initialization
-// =====================================================
-
-/// Initializes the OFT contract with token, endpoint, and decimal configuration.
-/// The `shared_decimals` must be <= token's local decimals.
-pub fn oft_initialize<T: OFT + OwnableInitializer>(
-    env: &Env,
-    owner: &Address,
-    token: &Address,
-    endpoint: &Address,
-    delegate: &Option<Address>,
-    shared_decimals: u32,
-) {
-    // Initialize OApp (includes owner initialization)
-    oapp_initialize::<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));
-}
+use soroban_sdk::{Address, Bytes, Env};
 
 // =====================================================
 // OFTInternal Trait (NOT exposed as contract endpoints)
@@ -106,17 +79,17 @@ pub trait OFTInternal: OAppCore {
     // Required Methods (no defaults - user MUST implement)
     // =========================================================================
 
-    /// Debits tokens from sender for cross-chain transfer.
+    /// Debits tokens from the specified address for cross-chain transfer.
     ///
     /// # Arguments
-    /// * `sender` - The address sending tokens
-    /// * `amount_ld` - Amount in local decimals to debit
-    /// * `min_amount_ld` - Minimum amount acceptable (slippage protection)
-    /// * `dst_eid` - Destination endpoint ID
+    /// * `from` - The address to debit the tokens from
+    /// * `amount_ld` - The amount of tokens to send in local decimals
+    /// * `min_amount_ld` - The minimum amount to send in local decimals
+    /// * `dst_eid` - The destination chain ID
     ///
     /// # Returns
-    /// Receipt with amounts sent and received (after fees/dust removal)
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt;
+    /// `OFTReceipt` containing the amount sent and amount received
+    fn __debit(env: &Env, from: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt;
 
     /// Credits tokens to recipient after receiving cross-chain transfer.
     ///
@@ -135,33 +108,20 @@ pub trait OFTInternal: OAppCore {
 
     /// Calculates debit amounts without executing (view function).
     fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        crate::default_oft_impl::default_debit_view(env, amount_ld, min_amount_ld, dst_eid)
+        oft_impl::debit_view(env, amount_ld, min_amount_ld, dst_eid)
     }
 
     /// Builds OFT message and combines options for cross-chain transfer.
     fn __build_msg_and_options(
         env: &Env,
-        sender: &Address,
+        from: &Address,
         send_param: &oft::types::SendParam,
-        amount_ld: i128,
+        receive_amount_ld: i128,
     ) -> (Bytes, Bytes)
     where
         Self: OAppOptionsType3,
     {
-        crate::default_oft_impl::default_build_msg_and_options::<Self>(env, sender, send_param, amount_ld)
-    }
-
-    /// Handles OFT receive logic.
-    fn __lz_receive(
-        env: &Env,
-        _executor: &Address,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        _extra_data: &Bytes,
-        _value: i128,
-    ) {
-        crate::default_oft_impl::default_lz_receive::<Self>(env, _executor, origin, guid, message, _extra_data, _value)
+        oft_impl::build_msg_and_options::<Self>(env, from, send_param, receive_amount_ld)
     }
 }
 
@@ -176,8 +136,8 @@ pub trait OFTInternal: OAppCore {
 ///
 /// Internal methods like `__debit`, `__credit`, `__debit_view`, and `__build_msg_and_options`
 /// are in the `OFTInternal` trait and are NOT exposed as contract endpoints.
-#[contracttrait(client_name = "OFTClient")]
-pub trait OFT: OFTInternal + OAppReceiver + OAppSender + OAppOptionsType3 {
+#[contract_trait]
+pub trait OFT: OFTInternal + OAppReceiver + OAppSenderInternal + OAppOptionsType3 {
     /// Retrieves the token address associated with this OFT.
     fn token(env: &Env) -> Address {
         OFTStorage::token(env).unwrap()
@@ -220,7 +180,7 @@ pub trait OFT: OFTInternal + OAppReceiver + OAppSender + OAppOptionsType3 {
         env: &Env,
         send_param: &oft::types::SendParam,
     ) -> (oft::types::OFTLimit, soroban_sdk::Vec<oft::types::OFTFeeDetail>, oft::types::OFTReceipt) {
-        crate::default_oft_impl::default_quote_oft::<Self>(env, send_param)
+        oft_impl::quote_oft::<Self>(env, send_param)
     }
 
     /// Quotes a send operation including LayerZero messaging fees.
@@ -230,7 +190,7 @@ pub trait OFT: OFTInternal + OAppReceiver + OAppSender + OAppOptionsType3 {
         send_param: &oft::types::SendParam,
         pay_in_zro: bool,
     ) -> endpoint_v2::MessagingFee {
-        crate::default_oft_impl::default_quote_send::<Self>(env, sender, send_param, pay_in_zro)
+        oft_impl::quote_send::<Self>(env, sender, send_param, pay_in_zro)
     }
 
     /// Sends tokens cross-chain to another endpoint.
@@ -246,6 +206,6 @@ pub trait OFT: OFTInternal + OAppReceiver + OAppSender + OAppOptionsType3 {
         fee: &endpoint_v2::MessagingFee,
         refund_address: &Address,
     ) -> (endpoint_v2::MessagingReceipt, oft::types::OFTReceipt) {
-        crate::default_oft_impl::default_send::<Self>(env, sender, send_param, fee, refund_address)
+        oft_impl::send::<Self>(env, sender, send_param, fee, refund_address)
     }
 }

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

@@ -0,0 +1,201 @@
+//! 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/oft_types/lock_unlock.rs

@@ -4,11 +4,9 @@
 //! tokens from the contract on credit (receive).
 //! Used for OFT adapters that wrap existing tokens.
 
+use crate::{oft::OFT, types::OFTReceipt};
 use soroban_sdk::{token::TokenClient, Address, Env};
 
-use crate::oft::OFT;
-use crate::types::OFTReceipt;
-
 /// Debit tokens using LockUnlock OFT type (locks tokens in contract).
 ///
 /// # Parameters

package/contracts/oapps/oft/src/oft_types/mint_burn.rs

@@ -3,12 +3,9 @@
 //! This OFT type burns tokens on debit (send) and mints tokens on credit (receive).
 //! Used when the OFT contract has mint/burn authority over the token.
 
+use crate::{interfaces::MintBurnTokenClient, oft::OFT, types::OFTReceipt};
 use soroban_sdk::{Address, Env};
 
-use crate::interfaces::MintBurnTokenClient;
-use crate::oft::OFT;
-use crate::types::OFTReceipt;
-
 /// Debit tokens using MintBurn OFT type (burns tokens from sender).
 ///
 /// # Parameters

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

@@ -3,9 +3,11 @@ use soroban_sdk::Address;
 
 #[storage]
 pub enum OFTStorage {
+    /// The decimal conversion rate used for cross-chain normalization
     #[instance(i128)]
     DecimalConversionRate,
 
+    /// The address of the underlying token contract
     #[instance(Address)]
     Token,
 }

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

@@ -5,21 +5,26 @@
 
 extern crate self as oft;
 
-use crate::default_oft_impl::{default_quote_oft, default_quote_send};
-use crate::errors::OFTError;
-use crate::extensions::oft_fee::{OFTFee, OFTFeeInternal};
-use crate::extensions::pausable::{OFTPausable, OFTPausableInternal};
-use crate::extensions::rate_limiter::{Direction, RateLimiter, RateLimiterInternal};
-use crate::oft::{oft_initialize, OFTInternal, OFT};
-use crate::storage::OFTStorage;
-use crate::tests::test_utils::{
-    create_recipient_address, DummyToken, MockEndpointWithCompose, MockEndpointWithComposeClient, DEFAULT_NATIVE_FEE,
-    DEFAULT_SHARED_DECIMALS, DEFAULT_ZRO_FEE, INITIAL_MINT_AMOUNT,
+use crate::{
+    errors::OFTError,
+    extensions::{
+        oft_fee::{OFTFee, OFTFeeInternal},
+        pausable::{OFTPausable, OFTPausableInternal},
+        rate_limiter::{Direction, RateLimiter, RateLimiterInternal},
+    },
+    initialize_oft,
+    oft::{OFTInternal, OFT},
+    oft_impl::{self, quote_oft, quote_send},
+    storage::OFTStorage,
+    tests::test_utils::{
+        create_recipient_address, DummyToken, MockEndpointWithCompose, MockEndpointWithComposeClient,
+        DEFAULT_NATIVE_FEE, DEFAULT_SHARED_DECIMALS, DEFAULT_ZRO_FEE, INITIAL_MINT_AMOUNT,
+    },
+    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
+    utils::remove_dust,
 };
-use crate::types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam};
-use crate::utils::remove_dust;
 use endpoint_v2::{LayerZeroReceiverClient, MessagingFee, MessagingReceipt, Origin};
-use oapp::oapp_core::OAppCoreClient;
+use oapp::{oapp_core::OAppCoreClient, oapp_receiver::LzReceiveInternal};
 use soroban_sdk::{
     assert_with_error, bytes, contractimpl, log,
     testutils::{Ledger, MockAuth, MockAuthInvoke},
@@ -33,6 +38,20 @@ use soroban_sdk::{
 #[oapp_macros::oapp]
 pub struct ExtensiveOFT;
 
+impl LzReceiveInternal for ExtensiveOFT {
+    fn __lz_receive(
+        env: &Env,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        extra_data: &Bytes,
+        executor: &Address,
+        value: i128,
+    ) {
+        oft_impl::lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+    }
+}
+
 #[contractimpl]
 impl ExtensiveOFT {
     pub fn __constructor(
@@ -43,7 +62,7 @@ impl ExtensiveOFT {
         delegate: &Option<Address>,
         shared_decimals: u32,
     ) {
-        oft_initialize::<Self>(env, owner, token, endpoint, delegate, shared_decimals);
+        initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals);
     }
 }
 
@@ -55,7 +74,7 @@ impl OFT for ExtensiveOFT {
         send_param: &crate::types::SendParam,
     ) -> (OFTLimit, soroban_sdk::Vec<OFTFeeDetail>, OFTReceipt) {
         Self::__assert_not_paused(env);
-        let (_, fee_details, oft_receipt) = default_quote_oft::<Self>(env, send_param);
+        let (_, fee_details, oft_receipt) = quote_oft::<Self>(env, send_param);
         let capacity = Self::rate_limit_capacity(env, &Direction::Outbound, send_param.dst_eid);
         let oft_limit = OFTLimit { min_amount_ld: 0, max_amount_ld: capacity };
         (oft_limit, fee_details, oft_receipt)
@@ -68,7 +87,7 @@ impl OFT for ExtensiveOFT {
         pay_in_zro: bool,
     ) -> endpoint_v2::MessagingFee {
         Self::__assert_not_paused(env);
-        default_quote_send::<Self>(env, sender, send_param, pay_in_zro)
+        quote_send::<Self>(env, sender, send_param, pay_in_zro)
     }
 }
 
@@ -86,12 +105,7 @@ impl OFTInternal for ExtensiveOFT {
         Self::__release_rate_limit_capacity(env, &Direction::Inbound, dst_eid, oft_receipt.amount_received_ld);
 
         // 4. Charge fee
-        Self::__charge_fee(
-            env,
-            &Self::token(env),
-            sender,
-            oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld,
-        );
+        Self::__charge_fee(env, &Self::token(env), sender, oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld);
 
         oft_receipt
     }

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

@@ -6,9 +6,11 @@
 //! - Fee deduction and transfer in send
 //! - Fee deposit address configuration
 
-use crate::extensions::oft_fee::OFTFeeError;
-use crate::tests::test_utils::{create_origin, create_recipient_address, encode_oft_message};
-use crate::utils::address_to_bytes32;
+use crate::{
+    extensions::oft_fee::OFTFeeError,
+    tests::test_utils::{create_origin, create_recipient_address, encode_oft_message},
+    utils::address_to_bytes32,
+};
 use endpoint_v2::MessagingFee;
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env, IntoVal};
 

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

@@ -6,9 +6,11 @@
 //! - `quote_send` is blocked
 //! - `quote_oft` works (view function, not blocked)
 
-use crate::extensions::pausable::OFTPausableError;
-use crate::tests::test_utils::{create_origin, create_recipient_address, encode_oft_message};
-use crate::utils::address_to_bytes32;
+use crate::{
+    extensions::pausable::OFTPausableError,
+    tests::test_utils::{create_origin, create_recipient_address, encode_oft_message},
+    utils::address_to_bytes32,
+};
 use endpoint_v2::MessagingFee;
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env, IntoVal};
 

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

@@ -7,9 +7,11 @@
 //! - Rate limit enforcement on lz_receive (inbound)
 //! - Capacity release on opposite direction
 
-use crate::extensions::rate_limiter::{Direction, RateLimitError};
-use crate::tests::test_utils::{create_origin, create_recipient_address, encode_oft_message};
-use crate::utils::address_to_bytes32;
+use crate::{
+    extensions::rate_limiter::{Direction, RateLimitError},
+    tests::test_utils::{create_origin, create_recipient_address, encode_oft_message},
+    utils::address_to_bytes32,
+};
 use endpoint_v2::MessagingFee;
 use soroban_sdk::{
     testutils::{Address as _, Ledger as _},

package/contracts/oapps/oft/src/tests/test_decimals.rs

@@ -17,7 +17,7 @@ fn test_decimal_conversion_rate() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #2100)")] // InvalidLocalDecimals
+#[should_panic(expected = "Error(Contract, #3000)")] // InvalidLocalDecimals
 fn test_invalid_local_decimals() {
     let env = Env::default();
     OFTTestSetupBuilder::new(&env).with_token_decimals(5).with_shared_decimals(6).build();
@@ -34,7 +34,7 @@ fn test_to_ld_overflow() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #2101)")] // Overflow
+#[should_panic(expected = "Error(Contract, #3002)")] // Overflow
 fn test_to_sd_overflow() {
     let env = Env::default();
 

package/contracts/oapps/oft/src/tests/test_oft_msg_codec.rs

@@ -1,5 +1,4 @@
-use crate::codec::oft_msg_codec::OFTMessage;
-use crate::utils::address_to_bytes32;
+use crate::{codec::oft_msg_codec::OFTMessage, utils::address_to_bytes32};
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
 
 #[test]