@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

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

@@ -1,20 +1,22 @@
-use core::ops::Mul;
+//! Utility functions for OFT-STD integration tests.
 
-use crate::{
-    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec},
-    integration_tests::setup::{decode_packet, ChainSetup},
-    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
-};
+use crate::extensions::rate_limiter::Direction;
+use crate::integration_tests::setup::{decode_packet, ChainSetup};
 use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
 use message_lib_common::packet_codec_v1;
+use oft_core::types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam};
 use soroban_sdk::{
     address_payload::AddressPayload,
-    testutils::{Events, MockAuth, MockAuthInvoke},
+    testutils::{Events, Ledger, MockAuth, MockAuthInvoke},
     token::StellarAssetClient,
     xdr::ToXdr,
     Address, Bytes, BytesN, Env, IntoVal, Map, Symbol, Val, Vec,
 };
 
+// ============================================================================
+// Address Conversion Utilities
+// ============================================================================
+
 pub fn address_to_peer_bytes32(address: &Address) -> BytesN<32> {
     match address.to_payload().unwrap() {
         AddressPayload::ContractIdHash(payload) => payload,
@@ -26,6 +28,16 @@ pub fn peer_bytes32_to_address(env: &Env, bytes32: &BytesN<32>) -> Address {
     AddressPayload::ContractIdHash(bytes32.clone()).to_address(env)
 }
 
+#[allow(dead_code)]
+pub fn create_recipient_address(env: &Env) -> Address {
+    let bytes = BytesN::from_array(env, &[0u8; 32]);
+    peer_bytes32_to_address(env, &bytes)
+}
+
+// ============================================================================
+// OFT Core Operations
+// ============================================================================
+
 pub fn quote_oft(chain: &ChainSetup<'_>, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
     chain.oft.quote_oft(send_param)
 }
@@ -49,6 +61,7 @@ pub fn quote_send(
     chain.oft.quote_send(sender, send_param, &pay_in_zro)
 }
 
+/// Send without fee (standard OFT send)
 pub fn send(
     env: &Env,
     chain: &ChainSetup<'_>,
@@ -83,6 +96,88 @@ pub fn send(
     chain.oft.send(sender, send_param, fee, refund_address);
 }
 
+/// Send with fee (OFT fee extension enabled)
+/// Order: transfer fee to deposit -> burn tokens -> transfer native fee
+pub fn send_with_fee(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    oft_receipt: &OFTReceipt,
+    fee_deposit_address: &Address,
+) {
+    let fee_amount = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "send",
+            args: (sender, send_param, fee, refund_address).into_val(env),
+            sub_invokes: &[
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "transfer",
+                    args: (sender, fee_deposit_address, &fee_amount).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "burn",
+                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.native_token,
+                    fn_name: "transfer",
+                    args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
+                    sub_invokes: &[],
+                },
+            ],
+        },
+    }]);
+    chain.oft.send(sender, send_param, fee, refund_address);
+}
+
+pub fn try_send(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    oft_receipt: &OFTReceipt,
+) -> bool {
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "send",
+            args: (sender, send_param, fee, refund_address).into_val(env),
+            sub_invokes: &[
+                MockAuthInvoke {
+                    contract: &chain.native_token,
+                    fn_name: "transfer",
+                    args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "burn",
+                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+                    sub_invokes: &[],
+                },
+            ],
+        },
+    }]);
+    chain.oft.try_send(sender, send_param, fee, refund_address).is_ok()
+}
+
+// ============================================================================
+// Packet Handling
+// ============================================================================
+
 pub fn validate_packet(env: &Env, chain: &ChainSetup<'_>, packet_event: &(Bytes, Bytes, Address)) {
     let packet = decode_packet(env, &packet_event.0);
     let encoded_header = packet_codec_v1::encode_packet_header(env, &packet);
@@ -131,26 +226,30 @@ pub fn lz_receive(
     );
 }
 
-pub fn lz_compose(
+pub fn try_lz_receive(
     env: &Env,
     chain: &ChainSetup<'_>,
     executor: &Address,
     packet: &OutboundPacket,
-    index: u32,
-    extra_data: &Bytes,
+    recipient: &Address,
     value: i128,
-) {
-    let oft_msg = oft_msg_codec::OFTMessage::decode(&packet.message);
-    let oft_compose_msg = OFTComposeMsg {
-        nonce: packet.nonce,
-        src_eid: packet.src_eid,
-        amount_ld: (oft_msg.amount_sd as i128).mul(chain.oft.decimal_conversion_rate()),
-        compose_from: oft_msg.compose_from.unwrap(),
-        compose_msg: oft_msg.compose_msg.unwrap(),
-    }
-    .encode(&env);
+) -> bool {
+    let origin =
+        Origin { src_eid: packet.src_eid, sender: address_to_peer_bytes32(&packet.sender), nonce: packet.nonce };
+    let extra_options = recipient.to_xdr(env);
 
-    chain.composer.lz_compose(executor, &chain.oft.address, &packet.guid, &index, &oft_compose_msg, extra_data, &value);
+    env.mock_auths(&[MockAuth {
+        address: executor,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "lz_receive",
+            args: (executor, &origin, &packet.guid, &packet.message, &extra_options, &value).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_v2::LayerZeroReceiverClient::new(env, &chain.oft.address)
+        .try_lz_receive(executor, &origin, &packet.guid, &packet.message, &extra_options, &value)
+        .is_ok()
 }
 
 // returns (encoded_payload, options, send_library)
@@ -172,6 +271,10 @@ pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, B
     packet
 }
 
+// ============================================================================
+// Token Operations
+// ============================================================================
+
 pub fn mint_to(env: &Env, owner: &Address, token: &Address, to: &Address, amount: i128) {
     env.mock_auths(&[MockAuth {
         address: owner,
@@ -199,3 +302,133 @@ pub fn transfer_sac_admin(env: &Env, owner: &Address, token: &Address, new_admin
     }]);
     StellarAssetClient::new(env, token).set_admin(new_admin);
 }
+
+pub fn token_balance(env: &Env, token: &Address, account: &Address) -> i128 {
+    soroban_sdk::token::TokenClient::new(env, token).balance(account)
+}
+
+// ============================================================================
+// Pausable Extension Operations
+// ============================================================================
+
+pub fn set_paused(env: &Env, chain: &ChainSetup<'_>, paused: bool) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_paused",
+            args: (&paused,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_paused(&paused);
+}
+
+pub fn is_paused(chain: &ChainSetup<'_>) -> bool {
+    chain.oft.is_paused()
+}
+
+// ============================================================================
+// OFT Fee Extension Operations
+// ============================================================================
+
+pub fn set_fee_deposit_address(env: &Env, chain: &ChainSetup<'_>, deposit_address: &Address) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_fee_deposit_address",
+            args: (deposit_address,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_fee_deposit_address(deposit_address);
+}
+
+pub fn set_default_fee_bps(env: &Env, chain: &ChainSetup<'_>, fee_bps: u64) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_default_fee_bps",
+            args: (&fee_bps,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_default_fee_bps(&fee_bps);
+}
+
+pub fn set_fee_bps(env: &Env, chain: &ChainSetup<'_>, dst_eid: u32, fee_bps: u64) {
+    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),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_fee_bps(&dst_eid, &fee_bps);
+}
+
+// ============================================================================
+// Rate Limiter Extension Operations
+// ============================================================================
+
+pub fn set_rate_limit(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    direction: &Direction,
+    dst_eid: u32,
+    limit: i128,
+    window_seconds: u64,
+) {
+    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),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_rate_limit(direction, &dst_eid, &limit, &window_seconds);
+}
+
+pub fn rate_limit_capacity(chain: &ChainSetup<'_>, direction: &Direction, eid: u32) -> i128 {
+    chain.oft.rate_limit_capacity(direction, &eid)
+}
+
+pub fn rate_limit_in_flight(chain: &ChainSetup<'_>, direction: &Direction, eid: u32) -> i128 {
+    chain.oft.rate_limit_in_flight(direction, &eid)
+}
+
+// ============================================================================
+// Time Utilities
+// ============================================================================
+
+pub fn advance_time(env: &Env, seconds: u64) {
+    let current = env.ledger().timestamp();
+    env.ledger().set_timestamp(current + seconds);
+}
+
+#[allow(dead_code)]
+pub fn set_timestamp(env: &Env, timestamp: u64) {
+    env.ledger().set_timestamp(timestamp);
+}
+
+// ============================================================================
+// SendParam Builder
+// ============================================================================
+
+pub fn create_send_param(env: &Env, dst_eid: u32, amount_ld: i128, min_amount_ld: i128, to: &BytesN<32>) -> SendParam {
+    SendParam {
+        dst_eid,
+        to: to.clone(),
+        amount_ld,
+        min_amount_ld,
+        extra_options: Bytes::new(env),
+        compose_msg: Bytes::new(env),
+        oft_cmd: Bytes::new(env),
+    }
+}

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

@@ -1,5 +1,5 @@
-use common_macros::{contract_error, only_owner, storage};
-use soroban_sdk::{assert_with_error, contractevent, contracttrait, token::TokenClient, Address, Env};
+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};
 
 /// Base fee in basis points (10,000 BPS = 100%)
@@ -52,9 +52,9 @@ pub struct FeeDepositAddressSet {
     pub fee_deposit_address: Address,
 }
 
-#[contracttrait]
+#[contract_trait]
 pub trait OFTFee: OFTFeeInternal + Ownable + Sized {
-    #[only_owner]
+    #[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);
@@ -63,7 +63,7 @@ pub trait OFTFee: OFTFeeInternal + Ownable + Sized {
         DefaultFeeBpsSet { fee_bps: default_fee_bps }.publish(env);
     }
 
-    #[only_owner]
+    #[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) {
@@ -74,14 +74,14 @@ pub trait OFTFee: OFTFeeInternal + Ownable + Sized {
         FeeBpsSet { dst_eid, fee_bps }.publish(env);
     }
 
-    #[only_owner]
+    #[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);
     }
 
-    #[only_owner]
+    #[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);
@@ -118,15 +118,15 @@ pub trait OFTFee: OFTFeeInternal + Ownable + Sized {
 /// Internal trait for OFT fee operations used by OFT hooks.
 /// Contains only truly internal methods that are called from OFTInner implementations.
 pub trait OFTFeeInternal {
-    /// Calculates the amount after fee deduction (read-only, mirrors `__debit_view`).
-    /// Used internally by `__debit_view` to calculate amount after fee.
+    /// Calculates the fee amount for a given transfer (read-only).
+    /// Used internally by `__debit_view` to calculate the 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)
+    /// 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) {
@@ -135,7 +135,7 @@ pub trait OFTFeeInternal {
             OFTFeeStorage::default_fee_bps(env)
         };
         if fee_bps == 0 {
-            return amount_ld;
+            return 0;
         }
         // Check that fee deposit address is set (required for fee collection)
         assert_with_error!(
@@ -143,8 +143,7 @@ pub trait OFTFeeInternal {
             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
+        (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.
@@ -155,7 +154,7 @@ pub trait OFTFeeInternal {
     /// * `sender` - The sender address to transfer fee from
     /// * `fee_amount` - The fee amount to transfer
     fn __charge_fee(env: &Env, token: &Address, sender: &Address, fee_amount: i128) {
-        if fee_amount > 0 {
+        if fee_amount != 0 {
             assert_with_error!(
                 env,
                 OFTFeeStorage::fee_deposit_address(env).is_some(),

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

@@ -1,5 +1,5 @@
-use common_macros::{contract_error, only_owner, storage};
-use soroban_sdk::{assert_with_error, contractevent, contracttrait, Env};
+use common_macros::{contract_error, contract_trait, only_auth, storage};
+use soroban_sdk::{assert_with_error, contractevent, Env};
 use utils::ownable::Ownable;
 
 #[storage]
@@ -21,9 +21,9 @@ pub struct PausedSet {
     pub paused: bool,
 }
 
-#[contracttrait]
+#[contract_trait]
 pub trait OFTPausable: OFTPausableInternal + Ownable + Sized {
-    #[only_owner]
+    #[only_auth]
     fn set_paused(env: &Env, paused: bool) {
         let current_paused = OFTPausableStorage::paused(env);
         assert_with_error!(env, current_paused != paused, OFTPausableError::PauseStatusUnchanged);

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

@@ -1,5 +1,5 @@
-use common_macros::{contract_error, only_owner, storage};
-use soroban_sdk::{assert_with_error, contractevent, contracttrait, contracttype, panic_with_error, Env};
+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;
 
 #[contracttype]
@@ -87,9 +87,9 @@ fn checkpoint_rate_limit_in_flight(env: &Env, direction: &Direction, eid: u32) {
     RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
 }
 
-#[contracttrait]
+#[contract_trait]
 pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
-    #[only_owner]
+    #[only_auth]
     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);
@@ -122,7 +122,7 @@ pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
         }
     }
 
-    #[only_owner]
+    #[only_auth]
     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);

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

@@ -1,21 +1,19 @@
 #![no_std]
 
-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;
-pub mod storage;
-pub mod types;
-pub mod utils;
+
+pub use extensions::*;
+pub use oft_types::*;
+
+cfg_if::cfg_if! {
+    // Include implementation when NOT in library mode, OR when testutils is enabled (for tests)
+    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
+        mod oft;
+        pub use oft::*;
+    }
+}
 
 #[cfg(test)]
 #[path = "../integration-tests/mod.rs"]
 pub mod integration_tests;
-
-#[cfg(test)]
-pub mod tests;