@layerzerolabs/protocol-stellar-v2 0.2.20 → 0.2.21

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

@@ -1,6 +1,6 @@
 //! Utility functions for OFT-STD integration tests.
 
-use crate::extensions::rate_limiter::Direction;
+use crate::extensions::rate_limiter::{Direction, RateLimitConfig};
 use crate::integration_tests::setup::{decode_packet, ChainSetup};
 use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
 use message_lib_common::packet_codec_v1;
@@ -254,10 +254,28 @@ pub fn try_lz_receive(
 
 // returns (encoded_payload, options, send_library)
 pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, Bytes, Address)> {
+    use soroban_sdk::TryFromVal;
+
     let mut packet = None;
-    for (emitter, topics, data) in env.events().all() {
-        let packet_sent_symbol = Symbol::new(env, "packet_sent").to_val();
-        if emitter == *endpoint && topics.contains(packet_sent_symbol) {
+    let events = env.events().all().filter_by_contract(endpoint);
+    for event in events.events().iter() {
+        let v0 = match &event.body {
+            soroban_sdk::xdr::ContractEventBody::V0(v0) => v0,
+        };
+
+        // Check if this is a packet_sent event by looking at topics
+        let mut is_packet_sent = false;
+        for topic in v0.topics.iter() {
+            if let Ok(sym) = Symbol::try_from_val(env, topic) {
+                if sym == Symbol::new(env, "packet_sent") {
+                    is_packet_sent = true;
+                    break;
+                }
+            }
+        }
+
+        if is_packet_sent {
+            let data: Val = Val::try_from_val(env, &v0.data).unwrap();
             let map: Map<Symbol, Val> = data.into_val(env);
 
             let encoded_payload: Bytes = map.get(Symbol::new(env, "encoded_packet")).unwrap().into_val(env);
@@ -359,16 +377,17 @@ pub fn set_default_fee_bps(env: &Env, chain: &ChainSetup<'_>, fee_bps: u64) {
 }
 
 pub fn set_fee_bps(env: &Env, chain: &ChainSetup<'_>, dst_eid: u32, fee_bps: u64) {
+    let fee_bps_opt = Some(fee_bps);
     env.mock_auths(&[MockAuth {
         address: &chain.owner,
         invoke: &MockAuthInvoke {
             contract: &chain.oft.address,
             fn_name: "set_fee_bps",
-            args: (&dst_eid, &fee_bps).into_val(env),
+            args: (&dst_eid, &fee_bps_opt).into_val(env),
             sub_invokes: &[],
         },
     }]);
-    chain.oft.set_fee_bps(&dst_eid, &fee_bps);
+    chain.oft.set_fee_bps(&dst_eid, &fee_bps_opt);
 }
 
 // ============================================================================
@@ -383,16 +402,17 @@ pub fn set_rate_limit(
     limit: i128,
     window_seconds: u64,
 ) {
+    let config = Some(RateLimitConfig { limit, window_seconds });
     env.mock_auths(&[MockAuth {
         address: &chain.owner,
         invoke: &MockAuthInvoke {
             contract: &chain.oft.address,
             fn_name: "set_rate_limit",
-            args: (direction, &dst_eid, &limit, &window_seconds).into_val(env),
+            args: (direction, &dst_eid, &config).into_val(env),
             sub_invokes: &[],
         },
     }]);
-    chain.oft.set_rate_limit(direction, &dst_eid, &limit, &window_seconds);
+    chain.oft.set_rate_limit(direction, &dst_eid, &config);
 }
 
 pub fn rate_limit_capacity(chain: &ChainSetup<'_>, direction: &Direction, eid: u32) -> i128 {

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

@@ -1,6 +1,6 @@
 use common_macros::{contract_error, contract_trait, only_auth, storage};
 use soroban_sdk::{assert_with_error, contractevent, token::TokenClient, Address, Env};
-use utils::{option_ext::OptionExt, ownable::Ownable};
+use utils::{auth::Auth, option_ext::OptionExt};
 
 /// Base fee in basis points (10,000 BPS = 100%)
 /// Used as denominator in fee calculations
@@ -12,13 +12,18 @@ const BASE_FEE_BPS: u64 = 10_000;
 
 #[storage]
 pub enum OFTFeeStorage {
+    /// Default fee rate in basis points (0-10,000, where 10,000 = 100%)
+    /// Applied to destinations without specific fee configuration
+    /// No fee is charged(default to 0) by default
     #[instance(u64)]
     #[default(0)]
     DefaultFeeBps,
 
+    /// Destination-specific fee rates mapped by endpoint ID (eid)
     #[persistent(u64)]
     FeeBps { eid: u32 },
 
+    /// Address where collected fees will be deposited
     #[instance(Address)]
     FeeDepositAddress,
 }
@@ -31,7 +36,6 @@ pub enum OFTFeeStorage {
 pub enum OFTFeeError {
     InvalidFeeBps = 3100,
     InvalidFeeDepositAddress,
-    NotFound,
     SameValue,
 }
 
@@ -49,13 +53,8 @@ pub struct DefaultFeeBpsSet {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct FeeBpsSet {
     pub dst_eid: u32,
-    pub fee_bps: u64,
-}
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct FeeBpsUnset {
-    pub dst_eid: u32,
+    /// The fee rate in basis points, or None if the fee is removed
+    pub fee_bps: Option<u64>,
 }
 
 #[contractevent]
@@ -69,71 +68,65 @@ pub struct FeeDepositAddressSet {
 // =========================================================================
 
 #[contract_trait]
-pub trait OFTFee: OFTFeeInternal + Ownable {
-    #[only_auth]
-    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);
-    }
+pub trait OFTFee: OFTFeeInternal + Auth {
+    // =========================================================================
+    // Management Functions
+    // =========================================================================
 
+    /// Sets the default fee rate in basis points.
     #[only_auth]
-    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);
+    fn set_default_fee_bps(env: &soroban_sdk::Env, default_fee_bps: u64) {
+        Self::__set_default_fee_bps(env, default_fee_bps);
     }
 
+    /// Sets or removes the fee rate for a specific destination endpoint.
+    ///
+    /// # Arguments
+    /// * `dst_eid` - The destination endpoint ID
+    /// * `fee_bps` - The fee rate (0-10,000), or None to remove the fee configuration
     #[only_auth]
-    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);
+    fn set_fee_bps(env: &soroban_sdk::Env, dst_eid: u32, fee_bps: Option<u64>) {
+        Self::__set_fee_bps(env, dst_eid, fee_bps);
     }
 
+    /// Sets the address where collected fees will be deposited.
     #[only_auth]
-    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 set_fee_deposit_address(env: &soroban_sdk::Env, fee_deposit_address: soroban_sdk::Address) {
+        Self::__set_fee_deposit_address(env, &fee_deposit_address);
     }
 
-    fn has_fee_bps(env: &Env, dst_eid: u32) -> bool {
-        Self::effective_fee_bps(env, dst_eid) > 0
-    }
+    // =========================================================================
+    // View Functions
+    // =========================================================================
 
-    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)
-        }
+    /// Returns the default fee rate in basis points.
+    fn default_fee_bps(env: &soroban_sdk::Env) -> u64 {
+        Self::__default_fee_bps(env)
     }
 
-    fn default_fee_bps(env: &Env) -> u64 {
-        OFTFeeStorage::default_fee_bps(env)
+    /// Returns the fee rate for a specific destination, if set.
+    fn fee_bps(env: &soroban_sdk::Env, dst_eid: u32) -> Option<u64> {
+        Self::__fee_bps(env, dst_eid)
     }
 
-    fn fee_bps(env: &Env, dst_eid: u32) -> Option<u64> {
-        OFTFeeStorage::fee_bps(env, dst_eid)
+    /// Returns the effective fee rate for a destination (destination-specific or default).
+    fn effective_fee_bps(env: &soroban_sdk::Env, dst_eid: u32) -> u64 {
+        Self::__effective_fee_bps(env, dst_eid)
     }
 
-    fn fee_deposit_address(env: &Env) -> Address {
-        OFTFeeStorage::fee_deposit_address(env).unwrap_or_panic(env, OFTFeeError::InvalidFeeDepositAddress)
+    /// Returns the fee deposit address.
+    fn fee_deposit_address(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+        Self::__fee_deposit_address(env)
     }
 }
 
 /// Internal trait for OFT fee operations used by OFT hooks.
-/// Contains only truly internal methods that are called from OFTInner implementations.
+/// Contains only truly internal methods that are called from OFTInternal implementations.
 pub trait OFTFeeInternal {
+    // =========================================================================
+    // OFT Hooks
+    // =========================================================================
+
     /// Calculates the fee amount for a given transfer (read-only).
     /// Used internally by `__debit_view` to calculate the fee.
     ///
@@ -144,40 +137,109 @@ pub trait OFTFeeInternal {
     /// # Returns
     /// The fee amount to be deducted
     fn __fee_view(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)
-        };
+        let fee_bps = Self::__effective_fee_bps(env, dst_eid);
         if fee_bps == 0 {
             return 0;
         }
+
         // Check that fee deposit address is set (required for fee collection)
-        assert_with_error!(
-            env,
-            OFTFeeStorage::fee_deposit_address(env).is_some(),
-            OFTFeeError::InvalidFeeDepositAddress
-        );
+        assert_with_error!(env, OFTFeeStorage::has_fee_deposit_address(env), OFTFeeError::InvalidFeeDepositAddress);
+
         (amount_ld * fee_bps as i128) / BASE_FEE_BPS as i128
     }
 
-    /// Charges the fee by transferring the fee amount from sender to the fee deposit address.
-    /// Used internally by `__debit` to collect the fee (mirrors `__debit`).
+    /// Charges the fee by transferring the fee amount from the sender to the fee deposit address.
+    /// Used internally by `__debit` to collect the fee.
     ///
     /// # Arguments
     /// * `token` - The token address to transfer
-    /// * `sender` - The sender address to transfer fee from
+    /// * `from` - The address to transfer fee from
     /// * `fee_amount` - The fee amount to transfer
-    fn __charge_fee(env: &Env, token: &Address, sender: &Address, fee_amount: i128) {
+    fn __charge_fee(env: &Env, token: &Address, from: &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);
+            let fee_deposit = Self::__fee_deposit_address(env);
+            TokenClient::new(env, token).transfer(from, &fee_deposit, &fee_amount);
+        }
+    }
+
+    // =========================================================================
+    // Management Functions
+    // =========================================================================
+
+    /// Sets the default fee rate in basis points.
+    ///
+    /// # Arguments
+    /// * `default_fee_bps` - The default fee rate (0-10,000, where 10,000 = 100%)
+    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 = Self::__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);
+    }
+
+    /// Sets or removes the fee rate for a specific destination endpoint.
+    ///
+    /// # Arguments
+    /// * `dst_eid` - The destination endpoint ID
+    /// * `fee_bps` - The fee rate (0-10,000), or None to remove the fee configuration
+    fn __set_fee_bps(env: &Env, dst_eid: u32, fee_bps: Option<u64>) {
+        let current_fee_bps = Self::__fee_bps(env, dst_eid);
+        assert_with_error!(env, current_fee_bps != fee_bps, OFTFeeError::SameValue);
+
+        match fee_bps {
+            Some(bps) => {
+                assert_with_error!(env, bps <= BASE_FEE_BPS, OFTFeeError::InvalidFeeBps);
+                OFTFeeStorage::set_fee_bps(env, dst_eid, &bps);
+            }
+            None => {
+                OFTFeeStorage::remove_fee_bps(env, dst_eid);
+            }
+        }
+
+        FeeBpsSet { dst_eid, fee_bps }.publish(env);
+    }
+
+    /// Sets the address where collected fees will be deposited.
+    ///
+    /// # Arguments
+    /// * `fee_deposit_address` - The address to deposit fees to
+    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: fee_deposit_address.clone() }.publish(env);
+    }
+
+    // =========================================================================
+    // View Functions
+    // =========================================================================
+
+    /// Returns the effective fee rate for a destination (destination-specific or default).
+    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)
         }
     }
+
+    /// Returns the default fee rate in basis points.
+    fn __default_fee_bps(env: &Env) -> u64 {
+        OFTFeeStorage::default_fee_bps(env)
+    }
+
+    /// Returns the fee rate for a specific destination, if set.
+    fn __fee_bps(env: &Env, dst_eid: u32) -> Option<u64> {
+        OFTFeeStorage::fee_bps(env, dst_eid)
+    }
+
+    /// Returns the fee deposit address.
+    fn __fee_deposit_address(env: &Env) -> Address {
+        OFTFeeStorage::fee_deposit_address(env).unwrap_or_panic(env, OFTFeeError::InvalidFeeDepositAddress)
+    }
 }

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

@@ -1,6 +1,6 @@
 use common_macros::{contract_error, contract_trait, only_auth, storage};
 use soroban_sdk::{assert_with_error, contractevent, Env};
-use utils::ownable::Ownable;
+use utils::auth::Auth;
 
 // =========================================================================
 // Storage
@@ -38,28 +38,62 @@ pub struct PausedSet {
 // =========================================================================
 
 #[contract_trait]
-pub trait OFTPausable: OFTPausableInternal + Ownable {
+pub trait OFTPausable: OFTPausableInternal + Auth {
+    /// Sets the paused state of the OFT.
+    ///
+    /// When paused, the OFT will reject new send/receive/quote_send/quote_oft operations.
+    ///
+    /// # Arguments
+    /// * `paused` - `true` to pause, `false` to unpause
     #[only_auth]
-    fn set_paused(env: &Env, paused: bool) {
-        assert_with_error!(env, Self::is_paused(env) != paused, OFTPausableError::PauseStatusUnchanged);
-        OFTPausableStorage::set_paused(env, &paused);
-        PausedSet { paused }.publish(env);
+    fn set_paused(env: &soroban_sdk::Env, paused: bool) {
+        Self::__set_paused(env, paused);
     }
 
-    fn is_paused(env: &Env) -> bool {
-        OFTPausableStorage::paused(env)
+    /// Returns the paused state of the OFT.
+    fn is_paused(env: &soroban_sdk::Env) -> bool {
+        Self::__is_paused(env)
     }
 }
 
 /// Internal trait for pausable operations used by OFT hooks.
 /// Contains only truly internal methods that are called from OFTInternal implementations.
 pub trait OFTPausableInternal {
+    // =========================================================================
+    // OFT Hooks
+    // =========================================================================
+
     /// Asserts that the OFT is not paused, panics otherwise.
-    /// Used internally by `send`, `quote_send`, and `__lz_receive` to enforce pause state.
+    /// Used internally by `send`, `quote_send`, `quote_oft`, 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);
+        assert_with_error!(env, !Self::__is_paused(env), OFTPausableError::Paused);
+    }
+
+    // =========================================================================
+    // Management Functions
+    // =========================================================================
+
+    /// Sets the paused state of the OFT.
+    ///
+    /// When paused, the OFT will reject new send/receive/quote_send/quote_oft operations.
+    ///
+    /// # Arguments
+    /// * `paused` - `true` to pause, `false` to unpause
+    fn __set_paused(env: &Env, paused: bool) {
+        assert_with_error!(env, Self::__is_paused(env) != paused, OFTPausableError::PauseStatusUnchanged);
+        OFTPausableStorage::set_paused(env, &paused);
+        PausedSet { paused }.publish(env);
+    }
+
+    // =========================================================================
+    // View Functions
+    // =========================================================================
+
+    /// Returns the paused state of the OFT.
+    fn __is_paused(env: &Env) -> bool {
+        OFTPausableStorage::paused(env)
     }
 }