@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.20

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

@@ -2,6 +2,10 @@ use common_macros::{contract_error, contract_trait, only_auth, storage};
 use soroban_sdk::{assert_with_error, contractevent, contracttype, panic_with_error, Env};
 use utils::ownable::Ownable;
 
+// =========================================================================
+// Types
+// =========================================================================
+
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[repr(u8)]
@@ -19,21 +23,33 @@ pub struct RateLimit {
     last_update: u64,
 }
 
+// =========================================================================
+// Storage
+// =========================================================================
+
 #[storage]
 pub enum RateLimitStorage {
     #[persistent(RateLimit)]
     RateLimit { direction: Direction, eid: u32 },
 }
 
+// =========================================================================
+// Errors
+// =========================================================================
+
 #[contract_error]
 pub enum RateLimitError {
-    ExceededRateLimit = 2400,
+    ExceededRateLimit = 3120,
     InvalidTimestamp,
     InvalidWindowSeconds,
     InvalidLimit,
     SameValue,
 }
 
+// =========================================================================
+// Events
+// =========================================================================
+
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct RateLimitSet {
@@ -59,33 +75,9 @@ pub struct RateLimitUnset {
     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
-    }
-}
-
-/// 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);
-}
+// =========================================================================
+// Trait With Default Implementations
+// =========================================================================
 
 #[contract_trait]
 pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
@@ -198,3 +190,35 @@ pub trait RateLimiterInternal {
         RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
     }
 }
+
+// =========================================================================
+// Helper Functions
+// =========================================================================
+
+/// 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
+    }
+}
+
+/// 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/oft.rs

@@ -7,25 +7,36 @@ use crate::{
     oft_types::{lock_unlock, mint_burn, OftType},
 };
 use common_macros::{contract_impl, storage};
-use endpoint_v2::{MessagingFee, Origin};
-use oapp::oapp_receiver::LzReceiveInternal;
+use endpoint_v2::Origin;
 use oapp_macros::oapp;
 use oft_core::{
     errors::OFTError,
+    impl_oft_lz_receive,
     types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
     utils as oft_utils, OFTCore, OFTInternal,
 };
 use soroban_sdk::{assert_with_error, vec, Address, Bytes, BytesN, Env, Vec};
 
+// =========================================================================
+// Storage
+// =========================================================================
+
 #[storage]
 enum OFTStorage {
     #[instance(OftType)]
     OftType,
 }
 
+// =========================================================================
+// OFT Contract
+// =========================================================================
+
 #[oapp]
 pub struct OFT;
 
+// LzReceiveInternal implementation using default OFT receive logic
+impl_oft_lz_receive!(OFT);
+
 #[contract_impl]
 impl OFT {
     pub fn __constructor(
@@ -37,7 +48,7 @@ impl OFT {
         shared_decimals: u32,
         oft_type: OftType,
     ) {
-        oft_core::initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals);
+        Self::__initialize_oft(env, owner, token, endpoint, delegate, shared_decimals);
         OFTStorage::set_oft_type(env, &oft_type);
     }
 
@@ -51,9 +62,7 @@ impl OFT {
 #[contract_impl(contracttrait)]
 impl OFTCore for OFT {
     fn quote_oft(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
-        Self::__assert_not_paused(env);
-
-        let oft_receipt = Self::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+        let (_, _, oft_receipt) = Self::__quote_oft(env, send_param);
 
         // fee details (only include if there's an actual fee)
         let fee_amount_ld = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
@@ -69,17 +78,15 @@ impl OFTCore for OFT {
 
         (oft_limit, fee_details, oft_receipt)
     }
-
-    fn quote_send(env: &Env, sender: &Address, send_param: &SendParam, pay_in_zro: bool) -> MessagingFee {
-        Self::__assert_not_paused(env);
-        oft_core::quote_send::<Self>(env, sender, send_param, pay_in_zro)
-    }
 }
 
 /// OFT behavior for standard OFT with extension hooks
 impl OFTInternal for OFT {
+    /// Overrides default to add pausable check and fee calculation.
     fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        let conversion_rate = Self::decimal_conversion_rate(env);
+        Self::__assert_not_paused(env);
+
+        let conversion_rate = Self::__decimal_conversion_rate(env);
 
         // Apply the fee before dust removal to ensure the fee is calculated on the full amount and dust is not transferred
         let fee = Self::__fee_view(env, dst_eid, amount_ld);
@@ -96,37 +103,34 @@ impl OFTInternal for OFT {
     }
 
     fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        // 1. Pausable check
-        Self::__assert_not_paused(env);
-
-        // 2. Core debit logic (based on oft_type)
+        // Core debit logic (based on oft_type)
         let oft_receipt = match Self::oft_type(env) {
             OftType::LockUnlock => lock_unlock::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid),
             OftType::MintBurn => mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid),
         };
 
-        // 3. Rate limit checks (using amount_received_ld - the actual cross-chain amount)
+        // Rate limit checks (using amount_received_ld - the actual cross-chain amount)
         Self::__consume_rate_limit_capacity(env, &Direction::Outbound, dst_eid, oft_receipt.amount_received_ld);
         Self::__release_rate_limit_capacity(env, &Direction::Inbound, dst_eid, oft_receipt.amount_received_ld);
 
-        // 4. Charge fee
+        // Charge fee
         let fee = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
-        Self::__charge_fee(env, &Self::token(env), sender, fee);
+        Self::__charge_fee(env, &Self::__token(env), sender, fee);
 
         oft_receipt
     }
 
     fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
-        // 1. Pausable check
+        // Pausable check
         Self::__assert_not_paused(env);
 
-        // 2. Core credit logic (based on mode)
+        // Core credit logic (based on mode)
         let amount_credited = match Self::oft_type(env) {
             OftType::LockUnlock => lock_unlock::credit::<Self>(env, to, amount_ld, src_eid),
             OftType::MintBurn => mint_burn::credit::<Self>(env, to, amount_ld, src_eid),
         };
 
-        // 3. Rate limit checks (using amount_credited - the actual credited amount)
+        // Rate limit checks (using amount_credited - the actual credited amount)
         Self::__consume_rate_limit_capacity(env, &Direction::Inbound, src_eid, amount_credited);
         Self::__release_rate_limit_capacity(env, &Direction::Outbound, src_eid, amount_credited);
 
@@ -134,40 +138,24 @@ impl OFTInternal for OFT {
     }
 }
 
-/// LzReceiveInternal implementation using default OFT receive logic
-impl LzReceiveInternal for OFT {
-    fn __lz_receive(
-        env: &Env,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        extra_data: &Bytes,
-        executor: &Address,
-        value: i128,
-    ) {
-        oft_core::lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
-    }
-}
-
-// ==================== Extension Trait Implementations ====================
+// =========================================================================
+// Extension Trait Implementations
+// =========================================================================
 
 /// Pausable extension - allows pausing/unpausing the OFT
 /// Default state: unpaused (all operations allowed)
 #[contract_impl(contracttrait)]
 impl OFTPausable for OFT {}
-
 impl OFTPausableInternal for OFT {}
 
 /// OFT Fee extension - allows collecting fees on transfers
 /// Default state: 0 BPS (no fee collected)
 #[contract_impl(contracttrait)]
 impl OFTFee for OFT {}
-
 impl OFTFeeInternal for OFT {}
 
 /// Rate Limiter extension - allows rate limiting transfers
 /// Default state: not set (rate_limit_capacity returns i128::MAX)
 #[contract_impl(contracttrait)]
 impl RateLimiter for OFT {}
-
 impl RateLimiterInternal for OFT {}

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

@@ -4,29 +4,7 @@
 //! Used when the OFT contract has mint/burn authority over the token.
 
 use oft_core::{oft_core::OFTCore, types::OFTReceipt};
-use soroban_sdk::{contractclient, Address, Env};
-
-/// Contract interface for mint and burn token operations.
-///
-/// This interface abstracts the token mint/burn functionality, allowing different
-/// token implementations (e.g., StellarAssetContract, custom tokens) to be used
-/// with the MintBurn OFT.
-#[contractclient(name = "MintBurnTokenClient")]
-pub trait MintBurnToken {
-    /// Mints tokens to the specified address.
-    ///
-    /// # Parameters
-    /// * `to` - The address to mint tokens to
-    /// * `amount` - The amount of tokens to mint (must be non-negative)
-    fn mint(env: Env, to: Address, amount: i128);
-
-    /// Burns tokens from the specified address.
-    ///
-    /// # Parameters
-    /// * `from` - The address to burn tokens from
-    /// * `amount` - The amount of tokens to burn (must be non-negative)
-    fn burn(env: Env, from: Address, amount: i128);
-}
+use soroban_sdk::{token::StellarAssetClient, Address, Env};
 
 /// Debit tokens using MintBurn OFT type (burns tokens from sender).
 ///
@@ -47,7 +25,7 @@ pub fn debit<T: OFTCore>(
     dst_eid: u32,
 ) -> OFTReceipt {
     let receipt = T::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
-    MintBurnTokenClient::new(env, &T::token(env)).burn(sender, &receipt.amount_received_ld);
+    StellarAssetClient::new(env, &T::token(env)).burn(sender, &receipt.amount_received_ld);
     receipt
 }
 
@@ -62,6 +40,6 @@ pub fn debit<T: OFTCore>(
 /// # Returns
 /// The amount credited
 pub fn credit<T: OFTCore>(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
-    MintBurnTokenClient::new(env, &T::token(env)).mint(to, &amount_ld);
+    StellarAssetClient::new(env, &T::token(env)).mint(to, &amount_ld);
     amount_ld
 }

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

@@ -7,7 +7,7 @@ extern crate std;
 use crate::{
     self as oft_core,
     integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address},
-    oft_core::{initialize_oft, lz_receive, OFTClient, OFTCore, OFTInternal},
+    oft_core::{lz_receive, OFTClient, OFTCore, OFTInternal},
     storage::OFTStorage,
     types::OFTReceipt,
 };
@@ -53,7 +53,7 @@ impl TestOFT {
         delegate: &Option<Address>,
         shared_decimals: u32,
     ) {
-        initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
+        Self::__initialize_oft(env, owner, token, endpoint, delegate, shared_decimals)
     }
 }