@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

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

@@ -1,4 +1,5 @@
 use crate::{
+    self as oft,
     extensions::{
         oft_fee::{OFTFee, OFTFeeInternal},
         pausable::{OFTPausable, OFTPausableInternal},
@@ -7,15 +8,18 @@ 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 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};
+use soroban_sdk::{assert_with_error, vec, Address, Bytes, Env, Vec};
+
+// =========================================================================
+// Storage
+// =========================================================================
 
 #[storage]
 enum OFTStorage {
@@ -23,9 +27,16 @@ enum OFTStorage {
     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,26 +78,31 @@ 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.
+    ///
+    /// Dust handling (consistent with EVM):
+    /// - fee = 0: dust stays with sender
+    /// - fee > 0: dust goes to fee recipient (included in charged fee)
     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);
 
-        // Apply the fee before dust removal to ensure the fee is calculated on the full amount and dust is not transferred
+        let conversion_rate = Self::__decimal_conversion_rate(env);
         let fee = Self::__fee_view(env, dst_eid, amount_ld);
-        let amount_after_fee = amount_ld - fee;
-        let amount_received_ld = oft_utils::remove_dust(amount_after_fee, conversion_rate);
 
-        // amount_sent_ld = what recipient receives + fee charged
-        // Dust is excluded (stays with sender)
-        let amount_sent_ld = amount_received_ld + fee;
+        let (amount_sent_ld, amount_received_ld) = if fee == 0 {
+            // No fee: dust stays with sender (default OFT behavior)
+            let amount_sent_ld = oft_utils::remove_dust(amount_ld, conversion_rate);
+            (amount_sent_ld, amount_sent_ld)
+        } else {
+            // With fee: match EVM OFTFee behavior
+            // - dust is included in charged fee (goes to fee recipient)
+            let amount_received_ld = oft_utils::remove_dust(amount_ld - fee, conversion_rate);
+            (amount_ld, amount_received_ld)
+        };
 
         assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
 
@@ -96,78 +110,59 @@ 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)
-        Self::__consume_rate_limit_capacity(env, &Direction::Inbound, src_eid, amount_credited);
-        Self::__release_rate_limit_capacity(env, &Direction::Outbound, src_eid, amount_credited);
+        // Rate limit checks
+        Self::__consume_rate_limit_capacity(env, &Direction::Inbound, src_eid, amount_ld);
+        Self::__release_rate_limit_capacity(env, &Direction::Outbound, src_eid, amount_ld);
 
         amount_credited
     }
 }
 
-/// 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/lock_unlock.rs

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

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

@@ -3,30 +3,8 @@
 //! 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 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 oft_core::{types::OFTReceipt, OFTCore};
+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/Cargo.toml

@@ -21,7 +21,4 @@ simple-message-lib = { workspace = true }
 message-lib-common = { workspace = true, features = ["testutils"] }
 endpoint-v2 = { workspace = true, features = ["testutils"] }
 utils = { workspace = true, features = ["testutils"] }
-insta = { workspace = true }
-oapp-macros = { workspace = true }
-stellar-macros = { workspace = true }
-stellar-tokens = { workspace = true }
+oapp-macros = { workspace = true }

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::{OFTClient, OFTCore, OFTInternal},
     storage::OFTStorage,
     types::OFTReceipt,
 };
@@ -39,7 +39,7 @@ impl LzReceiveInternal for TestOFT {
         executor: &Address,
         value: i128,
     ) {
-        lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+        <Self as OFTInternal>::__receive(env, origin, guid, message, extra_data, executor, value)
     }
 }
 
@@ -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)
     }
 }
 

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

@@ -155,10 +155,28 @@ pub fn lz_compose(
 
 // 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);

package/contracts/oapps/oft-core/src/errors.rs

@@ -1,12 +1,13 @@
 use common_macros::contract_error;
 
 // OFT library error codes: 3000-3099
-// See ERROR_SPEC.md for allocation rules
+// See docs/error-spec.md for allocation rules
 
 /// OFTError: 3000-3099
 #[contract_error]
 pub enum OFTError {
-    InvalidLocalDecimals = 3000,
+    InvalidAmount = 3000,
+    InvalidLocalDecimals,
     NotInitialized,
     Overflow,
     SlippageExceeded,

package/contracts/oapps/oft-core/src/events.rs

@@ -18,3 +18,9 @@ pub struct OFTReceived {
     pub to: Address,
     pub amount_received_ld: i128,
 }
+
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct MsgInspectorSet {
+    pub inspector: Option<Address>,
+}

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

@@ -3,7 +3,7 @@
 pub mod codec;
 pub mod errors;
 pub mod events;
-pub mod oft_core;
+mod oft_core;
 pub mod storage;
 pub mod types;
 pub mod utils;