@layerzerolabs/protocol-stellar-v2 0.2.10 → 0.2.11

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

@@ -4,7 +4,7 @@ use super::*;
 // ISendLib Contract Implementation
 // ==============================================================================
 
-#[contractimpl(contracttrait)]
+#[contract_impl(contracttrait)]
 impl ISendLib for Uln302 {
     /// Quotes the total fee for sending a cross-chain message.
     ///
@@ -81,7 +81,7 @@ impl ISendLib for Uln302 {
 // ISendUln302 Contract Implementation
 // ==============================================================================
 
-#[contractimpl(contracttrait)]
+#[contract_impl(contracttrait)]
 impl ISendUln302 for Uln302 {
     /// Sets default executor configurations for multiple destination endpoints.
     #[only_owner]

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

@@ -22,7 +22,7 @@ use message_lib_common::{
 };
 use soroban_sdk::{
     address_payload::AddressPayload,
-    assert_with_error, bytes, contract, contractimpl, panic_with_error, vec,
+    assert_with_error, bytes, contract, panic_with_error, vec,
     xdr::{FromXdr, ToXdr},
     Address, Bytes, BytesN, Env, Map, Vec,
 };
@@ -54,7 +54,7 @@ impl Uln302 {
     }
 }
 
-#[contractimpl(contracttrait)]
+#[contract_impl(contracttrait)]
 impl IMessageLib for Uln302 {
     /// Sets OApp-specific configuration parameters for the message library.
     ///

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

@@ -31,8 +31,8 @@ pub fn generate_impl(name: &Ident, item_struct: ItemStruct, manual_impl_core: bo
     });
 
     quote! {
-        #[common_macros::ownable]
         #[soroban_sdk::contract]
+        #[common_macros::ttl_configurable]
         #item_struct
 
         #manual_impl

package/contracts/oapps/oft/integration-tests/setup.rs

@@ -29,8 +29,8 @@ pub struct TestOFT;
 
 #[contract_impl]
 impl TestOFT {
-    pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
-        oft_initialize::<Self>(env, owner, token, endpoint, delegate)
+    pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Option<Address>, shared_decimals: u32) {
+        oft_initialize::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
     }
 }
 
@@ -153,7 +153,8 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let fee_recipient = Address::generate(env);
     let sml_address = env.register(SimpleMessageLib, (&owner, &endpoint_address, &fee_recipient));
     let delegate: Option<Address> = Some(owner.clone());
-    let oft_address = env.register(TestOFT, (&oft_token, &owner, &endpoint_address, &delegate));
+    let shared_decimals: u32 = 6; // Default shared decimals
+    let oft_address = env.register(TestOFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals));
     let composer_address = env.register(DummyComposer, (&endpoint_address,));
 
     let endpoint = EndpointV2Client::new(env, &endpoint_address);

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

@@ -0,0 +1,146 @@
+//! 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::OFTInner,
+{
+    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::OFTInner,
+{
+    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/extensions/mod.rs

@@ -0,0 +1,3 @@
+pub mod oft_fee;
+pub mod pausable;
+pub mod rate_limiter;

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

@@ -0,0 +1,164 @@
+use common_macros::{contract_error, event, only_owner, storage};
+use soroban_sdk::{assert_with_error, contracttrait, token::TokenClient, Address, Env};
+use utils::{option_ext::OptionExt, ownable::Ownable};
+
+/// Base fee in basis points (10,000 BPS = 100%)
+/// Used as denominator in fee calculations
+const BASE_FEE_BPS: u64 = 10_000;
+
+#[storage]
+pub enum OFTFeeStorage {
+    #[instance(u64)]
+    #[default(0)]
+    DefaultFeeBps,
+
+    #[persistent(u64)]
+    FeeBps { eid: u32 },
+
+    #[instance(Address)]
+    FeeDepositAddress,
+}
+
+#[contract_error]
+pub enum OFTFeeError {
+    InvalidFeeBps = 2200,
+    InvalidFeeDepositAddress,
+    NotFound,
+    SameValue,
+}
+
+#[event]
+pub struct DefaultFeeBpsSet {
+    pub fee_bps: u64,
+}
+
+#[event]
+pub struct FeeBpsSet {
+    pub dst_eid: u32,
+    pub fee_bps: u64,
+}
+
+#[event]
+pub struct FeeBpsUnset {
+    pub dst_eid: u32,
+}
+
+#[event]
+pub struct FeeDepositAddressSet {
+    pub fee_deposit_address: Address,
+}
+
+#[contracttrait]
+pub trait OFTFee: OFTFeeInternal + Ownable + Sized {
+    #[only_owner]
+    fn set_default_fee_bps(env: &Env, default_fee_bps: u64) {
+        assert_with_error!(env, default_fee_bps <= BASE_FEE_BPS, OFTFeeError::InvalidFeeBps);
+        let current_default = OFTFeeStorage::default_fee_bps(env);
+        assert_with_error!(env, current_default != default_fee_bps, OFTFeeError::SameValue);
+        OFTFeeStorage::set_default_fee_bps(env, &default_fee_bps);
+        DefaultFeeBpsSet { fee_bps: default_fee_bps }.publish(env);
+    }
+
+    #[only_owner]
+    fn set_fee_bps(env: &Env, dst_eid: u32, fee_bps: u64) {
+        assert_with_error!(env, fee_bps <= BASE_FEE_BPS, OFTFeeError::InvalidFeeBps);
+        if OFTFeeStorage::has_fee_bps(env, dst_eid) {
+            let current_fee_bps = OFTFeeStorage::fee_bps(env, dst_eid).unwrap();
+            assert_with_error!(env, current_fee_bps != fee_bps, OFTFeeError::SameValue);
+        }
+        OFTFeeStorage::set_fee_bps(env, dst_eid, &fee_bps);
+        FeeBpsSet { dst_eid, fee_bps }.publish(env);
+    }
+
+    #[only_owner]
+    fn unset_fee_bps(env: &Env, dst_eid: u32) {
+        assert_with_error!(env, OFTFeeStorage::has_fee_bps(env, dst_eid), OFTFeeError::NotFound);
+        OFTFeeStorage::remove_fee_bps(env, dst_eid);
+        FeeBpsUnset { dst_eid }.publish(env);
+    }
+
+    #[only_owner]
+    fn set_fee_deposit_address(env: &Env, fee_deposit_address: Address) {
+        if let Some(current_address) = OFTFeeStorage::fee_deposit_address(env) {
+            assert_with_error!(env, current_address != fee_deposit_address, OFTFeeError::SameValue);
+        }
+        OFTFeeStorage::set_fee_deposit_address(env, &fee_deposit_address);
+        FeeDepositAddressSet { fee_deposit_address }.publish(env);
+    }
+
+    fn has_fee_bps(env: &Env, dst_eid: u32) -> bool {
+        Self::effective_fee_bps(env, dst_eid) > 0
+    }
+
+    fn effective_fee_bps(env: &Env, dst_eid: u32) -> u64 {
+        if OFTFeeStorage::has_fee_bps(env, dst_eid) {
+            OFTFeeStorage::fee_bps(env, dst_eid).unwrap()
+        } else {
+            OFTFeeStorage::default_fee_bps(env)
+        }
+    }
+
+    fn default_fee_bps(env: &Env) -> u64 {
+        OFTFeeStorage::default_fee_bps(env)
+    }
+
+    fn fee_bps(env: &Env, dst_eid: u32) -> Option<u64> {
+        OFTFeeStorage::fee_bps(env, dst_eid)
+    }
+
+    fn fee_deposit_address(env: &Env) -> Address {
+        OFTFeeStorage::fee_deposit_address(env).unwrap_or_panic(env, OFTFeeError::InvalidFeeDepositAddress)
+    }
+}
+
+/// Internal trait for OFT fee operations used by OFT hooks.
+/// Contains only truly internal methods that are called from OFTInner implementations.
+pub trait OFTFeeInternal {
+    /// Applies the configured fee to the given amount and returns the amount after fee deduction.
+    /// Used internally by `__debit_view` to calculate amount after fee.
+    ///
+    /// # Arguments
+    /// * `dst_eid` - Destination endpoint ID to determine which fee rate to apply
+    /// * `amount_ld` - The original amount in local decimals
+    ///
+    /// # Returns
+    /// The amount after fee deduction (original amount - calculated fee)
+    fn __apply_fee(env: &Env, dst_eid: u32, amount_ld: i128) -> i128 {
+        // Calculate effective fee (destination-specific or default)
+        let fee_bps = if OFTFeeStorage::has_fee_bps(env, dst_eid) {
+            OFTFeeStorage::fee_bps(env, dst_eid).unwrap()
+        } else {
+            OFTFeeStorage::default_fee_bps(env)
+        };
+        if fee_bps == 0 {
+            return amount_ld;
+        }
+        // Check that fee deposit address is set (required for fee collection)
+        assert_with_error!(
+            env,
+            OFTFeeStorage::fee_deposit_address(env).is_some(),
+            OFTFeeError::InvalidFeeDepositAddress
+        );
+        let preliminary_fee = (amount_ld * fee_bps as i128) / BASE_FEE_BPS as i128;
+        amount_ld - preliminary_fee
+    }
+
+    /// Transfers the fee amount from sender to the fee deposit address.
+    /// Used internally by `__debit` to collect the fee after calculating the debit amounts.
+    ///
+    /// # Arguments
+    /// * `token` - The token address to transfer
+    /// * `sender` - The sender address to transfer fee from
+    /// * `fee_amount` - The fee amount to transfer
+    fn __transfer_fee(env: &Env, token: &Address, sender: &Address, fee_amount: i128) {
+        if fee_amount > 0 {
+            assert_with_error!(
+                env,
+                OFTFeeStorage::fee_deposit_address(env).is_some(),
+                OFTFeeError::InvalidFeeDepositAddress
+            );
+            let fee_deposit = OFTFeeStorage::fee_deposit_address(env).unwrap();
+            TokenClient::new(env, token).transfer(sender, &fee_deposit, &fee_amount);
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+use common_macros::{contract_error, event, only_owner, storage};
+use soroban_sdk::{assert_with_error, contracttrait, Env};
+use utils::ownable::Ownable;
+
+#[storage]
+pub enum OFTPausableStorage {
+    #[instance(bool)]
+    #[default(false)]
+    Paused,
+}
+
+#[contract_error]
+pub enum OFTPausableError {
+    Paused = 2300,
+    PauseStatusUnchanged,
+}
+
+#[event]
+pub struct PausedSet {
+    pub paused: bool,
+}
+
+#[contracttrait]
+pub trait OFTPausable: OFTPausableInternal + Ownable + Sized {
+    #[only_owner]
+    fn set_paused(env: &Env, paused: bool) {
+        let current_paused = OFTPausableStorage::paused(env);
+        assert_with_error!(env, current_paused != paused, OFTPausableError::PauseStatusUnchanged);
+        OFTPausableStorage::set_paused(env, &paused);
+        PausedSet { paused }.publish(env);
+    }
+
+    fn is_paused(env: &Env) -> bool {
+        OFTPausableStorage::paused(env)
+    }
+}
+
+/// Internal trait for pausable operations used by OFT hooks.
+/// Contains only truly internal methods that are called from OFTInner implementations.
+pub trait OFTPausableInternal {
+    /// Asserts that the OFT is not paused, panics otherwise.
+    /// Used internally by `send`, `quote_send`, and `__lz_receive` to enforce pause state.
+    ///
+    /// # Errors
+    /// * `Paused` - If the OFT is currently paused.
+    fn __assert_not_paused(env: &Env) {
+        assert_with_error!(env, !OFTPausableStorage::paused(env), OFTPausableError::Paused);
+    }
+}
+

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

@@ -0,0 +1,198 @@
+use common_macros::{contract_error, event, only_owner, storage};
+use soroban_sdk::{assert_with_error, contracttrait, contracttype, panic_with_error, Env};
+use utils::ownable::Ownable;
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[repr(u8)]
+pub enum Direction {
+    Inbound,
+    Outbound,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct RateLimit {
+    limit: i128,
+    window_seconds: u64,
+    in_flight_on_last_update: i128,
+    last_update: u64,
+}
+
+#[storage]
+pub enum RateLimitStorage {
+    #[persistent(RateLimit)]
+    RateLimit { direction: Direction, eid: u32 },
+}
+
+#[contract_error]
+pub enum RateLimitError {
+    ExceededRateLimit = 2400,
+    InvalidTimestamp,
+    InvalidWindowSeconds,
+    InvalidLimit,
+    SameValue,
+}
+
+#[event]
+pub struct RateLimitSet {
+    pub direction: Direction,
+    pub eid: u32,
+    pub limit: i128,
+    pub window_seconds: u64,
+}
+
+#[event]
+pub struct RateLimitUpdated {
+    pub direction: Direction,
+    pub eid: u32,
+    pub limit: i128,
+    pub window_seconds: u64,
+}
+
+#[event]
+pub struct RateLimitUnset {
+    pub direction: Direction,
+    pub eid: u32,
+}
+
+/// Helper function to calculate the current in-flight amount with decay.
+/// Used by both public trait methods and internal implementations.
+fn calculate_in_flight(env: &Env, direction: &Direction, eid: u32) -> i128 {
+    if !RateLimitStorage::has_rate_limit(env, direction, eid) {
+        return 0;
+    }
+    let rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+    let timestamp = env.ledger().timestamp();
+    assert_with_error!(env, timestamp >= rate_limit.last_update, RateLimitError::InvalidTimestamp);
+    let elapsed = timestamp - rate_limit.last_update;
+    let decay = (elapsed as i128) * rate_limit.limit / (rate_limit.window_seconds as i128);
+    if decay < rate_limit.in_flight_on_last_update {
+        rate_limit.in_flight_on_last_update - decay
+    } else {
+        0
+    }
+}
+
+#[contracttrait]
+pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
+    #[only_owner]
+    fn set_rate_limit(env: &Env, direction: &Direction, eid: u32, limit: i128, window_seconds: u64) {
+        assert_with_error!(env, limit > 0, RateLimitError::InvalidLimit);
+        assert_with_error!(env, window_seconds > 0, RateLimitError::InvalidWindowSeconds);
+        if RateLimitStorage::has_rate_limit(env, direction, eid) {
+            let rate_limit_data = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+            assert_with_error!(
+                env,
+                limit != rate_limit_data.limit || window_seconds != rate_limit_data.window_seconds,
+                RateLimitError::SameValue
+            );
+            Self::__checkpoint_rate_limit_in_flight(env, direction, eid);
+            let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+            rate_limit.limit = limit;
+            rate_limit.window_seconds = window_seconds;
+            RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
+            RateLimitUpdated { direction: direction.clone(), eid, limit, window_seconds }.publish(env);
+        } else {
+            RateLimitStorage::set_rate_limit(
+                env,
+                direction,
+                eid,
+                &RateLimit {
+                    limit,
+                    window_seconds,
+                    in_flight_on_last_update: 0,
+                    last_update: env.ledger().timestamp(),
+                },
+            );
+            RateLimitSet { direction: direction.clone(), eid, limit, window_seconds }.publish(env);
+        }
+    }
+
+    #[only_owner]
+    fn unset_rate_limit(env: &Env, direction: &Direction, eid: u32) {
+        assert_with_error!(env, RateLimitStorage::has_rate_limit(env, direction, eid), RateLimitError::SameValue);
+        RateLimitStorage::remove_rate_limit(env, direction, eid);
+        RateLimitUnset { direction: direction.clone(), eid }.publish(env);
+    }
+
+    fn rate_limit_config(env: &Env, direction: &Direction, eid: u32) -> (i128, u64) {
+        if !RateLimitStorage::has_rate_limit(env, direction, eid) {
+            return (0, 0);
+        }
+        let rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+        (rate_limit.limit, rate_limit.window_seconds)
+    }
+
+    fn rate_limit_in_flight(env: &Env, direction: &Direction, eid: u32) -> i128 {
+        calculate_in_flight(env, direction, eid)
+    }
+
+    fn rate_limit_capacity(env: &Env, direction: &Direction, eid: u32) -> i128 {
+        if !RateLimitStorage::has_rate_limit(env, direction, eid) {
+            return i128::MAX;
+        }
+        let rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+        let in_flight = calculate_in_flight(env, direction, eid);
+        if rate_limit.limit > in_flight {
+            rate_limit.limit - in_flight
+        } else {
+            0
+        }
+    }
+}
+
+/// Internal trait for rate limiter operations used by OFT hooks.
+/// Contains only truly internal methods that are called from OFTInner implementations.
+pub trait RateLimiterInternal {
+    /// Tries to consume the specified amount from the rate limit capacity.
+    /// Used internally by `send` and `__lz_receive` to enforce rate limits.
+    ///
+    /// # Errors
+    /// * `ExceededRateLimit` - If the amount exceeds the available capacity.
+    fn __try_consume_rate_limit_capacity(env: &Env, direction: &Direction, eid: u32, amount: i128) {
+        if !RateLimitStorage::has_rate_limit(env, direction, eid) {
+            return;
+        }
+        Self::__checkpoint_rate_limit_in_flight(env, direction, eid);
+        let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+        // Check against remaining capacity (limit - current in_flight), not total limit
+        let capacity = if rate_limit.limit > rate_limit.in_flight_on_last_update {
+            rate_limit.limit - rate_limit.in_flight_on_last_update
+        } else {
+            0
+        };
+        if amount > capacity {
+            panic_with_error!(env, RateLimitError::ExceededRateLimit);
+        }
+        rate_limit.in_flight_on_last_update += amount;
+        RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
+    }
+
+    /// Releases the specified amount back to the rate limit capacity.
+    /// Used internally by `__lz_receive` to release outbound capacity on inbound messages.
+    fn __release_rate_limit_capacity(env: &Env, direction: &Direction, eid: u32, amount: i128) {
+        if !RateLimitStorage::has_rate_limit(env, direction, eid) {
+            return;
+        }
+        Self::__checkpoint_rate_limit_in_flight(env, direction, eid);
+        let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+        if amount >= rate_limit.in_flight_on_last_update {
+            rate_limit.in_flight_on_last_update = 0;
+        } else {
+            rate_limit.in_flight_on_last_update -= amount;
+        }
+        RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
+    }
+
+    /// Checkpoints the current in-flight amount by applying decay and updating timestamp.
+    /// Used internally before modifying rate limit state.
+    fn __checkpoint_rate_limit_in_flight(env: &Env, direction: &Direction, eid: u32) {
+        let in_flight = calculate_in_flight(env, direction, eid);
+        let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+        rate_limit.in_flight_on_last_update = in_flight;
+        rate_limit.last_update = env.ledger().timestamp();
+        RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
+    }
+}
+

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

@@ -2,8 +2,10 @@
 
 pub mod codec;
 pub mod constants;
+pub mod default_oft_impl;
 pub mod errors;
 pub mod events;
+pub mod extensions;
 pub mod interfaces;
 pub mod oft;
 pub mod oft_types;
@@ -15,8 +17,5 @@ pub mod utils;
 #[path = "../integration-tests/mod.rs"]
 pub mod integration_tests;
 
-#[cfg(test)]
-pub mod macro_tests;
-
 #[cfg(test)]
 pub mod tests;