@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/message-libs/simple-message-lib/src/simple_message_lib.rs

@@ -1,15 +1,13 @@
 use crate::{errors::SimpleMessageLibError, storage::SmlStorage};
-use common_macros::{contract_impl, only_owner, ttl_configurable};
+use common_macros::{contract_impl, lz_contract, only_auth};
 use endpoint_v2::{
     FeeRecipient, FeesAndPacket, IMessageLib, ISendLib, LayerZeroEndpointV2Client, MessageLibType, MessageLibVersion,
     MessagingFee, Origin, OutboundPacket, SetConfigParam,
 };
 use message_lib_common::packet_codec_v1;
-use soroban_sdk::{address_payload::AddressPayload, contract, panic_with_error, vec, Address, Bytes, BytesN, Env, Vec};
-use utils::ownable::Ownable;
+use soroban_sdk::{address_payload::AddressPayload, panic_with_error, vec, Address, Bytes, BytesN, Env, Vec};
 
-#[contract]
-#[ttl_configurable]
+#[lz_contract]
 pub struct SimpleMessageLib;
 
 #[contract_impl]
@@ -43,22 +41,22 @@ impl SimpleMessageLib {
     // Admin Manager
     // ============================================================================================
 
-    #[only_owner]
+    #[only_auth]
     pub fn set_fee_recipient(env: &Env, fee_recipient: &Address) {
         SmlStorage::set_fee_recipient(env, fee_recipient);
     }
 
-    #[only_owner]
+    #[only_auth]
     pub fn set_native_fee(env: &Env, native_fee: &i128) {
         SmlStorage::set_native_fee(env, native_fee);
     }
 
-    #[only_owner]
+    #[only_auth]
     pub fn set_zro_fee(env: &Env, zro_fee: &i128) {
         SmlStorage::set_zro_fee(env, zro_fee);
     }
 
-    #[only_owner]
+    #[only_auth]
     pub fn set_whitelisted_caller(env: &Env, whitelisted_caller: &Address) {
         SmlStorage::set_whitelisted_caller(env, whitelisted_caller);
     }

package/contracts/message-libs/treasury/src/errors.rs

@@ -4,7 +4,6 @@ use common_macros::contract_error;
 pub enum TreasuryError {
     InvalidNativeFeeBp,
     InvalidTotalNativeFee,
-    InvalidZROFee,
-    InvalidZROFeeLib,
-    ZROFeeLibNotSet,
+    InvalidZroFee,
+    ZroFeeLibNotSet,
 }

package/contracts/message-libs/treasury/src/events.rs

@@ -17,7 +17,7 @@ pub struct FeeEnabledSet {
 /// Emitted when the ZRO fee library is set or removed.
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct ZROFeeLibSet {
+pub struct ZroFeeLibSet {
     pub zro_fee_lib: Option<Address>,
 }
 

package/contracts/message-libs/treasury/src/interfaces/zro_fee_lib.rs

@@ -4,8 +4,8 @@ use soroban_sdk::{contractclient, Address, Env};
 ///
 /// The ZRO token fee library calculates treasury fees when paying in ZRO tokens.
 /// This allows for custom fee calculation logic when users opt to pay fees in ZRO.
-#[contractclient(name = "ZROFeeLibClient")]
-pub trait IZROFeeLib {
+#[contractclient(name = "ZroFeeLibClient")]
+pub trait IZroFeeLib {
     /// Get the treasury fee in ZRO tokens based on the worker fee.
     ///
     /// # Arguments

package/contracts/message-libs/treasury/src/lib.rs

@@ -1,17 +1,17 @@
 #![no_std]
 
+mod errors;
+pub mod events;
 mod interfaces;
 
+pub use errors::*;
 pub use interfaces::*;
 
 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 errors;
-        mod events;
         mod storage;
         mod treasury;
-
         pub use treasury::{Treasury, TreasuryClient};
     }
 }

package/contracts/message-libs/treasury/src/storage.rs

@@ -5,13 +5,15 @@ use soroban_sdk::Address;
 pub enum TreasuryStorage {
     /// Native fee in basis points (0-10000, where 10000 = 100%)
     #[instance(u32)]
+    #[default(0)]
     NativeFeeBp,
 
     /// Global toggle for all fee collection
     #[instance(bool)]
+    #[default(false)]
     FeeEnabled,
 
     /// Address of the ZRO token fee library contract for custom fee calculations
     #[instance(Address)]
-    ZROFeeLib,
+    ZroFeeLib,
 }

package/contracts/message-libs/treasury/src/tests/treasury_tests.rs

@@ -70,7 +70,7 @@ fn test_get_fee_zro_payment_requires_fee_lib() {
 
     // Should fail when trying to pay in ZRO without fee lib set
     let result = setup.treasury.try_get_fee(&sender, &dst_eid, &1000, &true);
-    assert_eq!(result.err().unwrap().ok().unwrap(), TreasuryError::ZROFeeLibNotSet.into());
+    assert_eq!(result.err().unwrap().ok().unwrap(), TreasuryError::ZroFeeLibNotSet.into());
 }
 
 // ============================================================================

package/contracts/message-libs/treasury/src/treasury.rs

@@ -1,19 +1,18 @@
 use crate::{
     errors::TreasuryError,
-    events::{FeeEnabledSet, NativeFeeBpSet, TokenWithdrawn, ZROFeeLibSet},
-    interfaces::ZROFeeLibClient,
+    events::{FeeEnabledSet, NativeFeeBpSet, TokenWithdrawn, ZroFeeLibSet},
+    interfaces::ZroFeeLibClient,
     storage::TreasuryStorage,
 };
-use common_macros::{contract_impl, only_owner, ttl_configurable};
+use common_macros::{contract_impl, lz_contract, only_auth};
 use message_lib_common::interfaces::ILayerZeroTreasury;
-use soroban_sdk::{assert_with_error, contract, token::Client, Address, Env};
+use soroban_sdk::{assert_with_error, token::Client, Address, Env};
 use utils::option_ext::OptionExt;
 
 /// Denominator for basis point calculations (10000 = 100%).
 const BPS_DENOMINATOR: u32 = 10000;
 
-#[contract]
-#[ttl_configurable]
+#[lz_contract]
 pub struct Treasury;
 
 #[contract_impl]
@@ -30,7 +29,7 @@ impl Treasury {
     ///
     /// # Arguments
     /// * `native_fee_bp` - Fee percentage in basis points (0-10000, where 10000 = 100%)
-    #[only_owner]
+    #[only_auth]
     pub fn set_native_fee_bp(env: &Env, native_fee_bp: u32) {
         assert_with_error!(env, native_fee_bp <= BPS_DENOMINATOR, TreasuryError::InvalidNativeFeeBp);
         TreasuryStorage::set_native_fee_bp(env, &native_fee_bp);
@@ -41,7 +40,7 @@ impl Treasury {
     ///
     /// # Arguments
     /// * `fee_enabled` - Whether fee collection is enabled
-    #[only_owner]
+    #[only_auth]
     pub fn set_fee_enabled(env: &Env, fee_enabled: bool) {
         TreasuryStorage::set_fee_enabled(env, &fee_enabled);
         FeeEnabledSet { fee_enabled }.publish(env);
@@ -51,10 +50,10 @@ impl Treasury {
     ///
     /// # Arguments
     /// * `zro_fee_lib` - The ZRO fee library contract address, or `None` to remove
-    #[only_owner]
+    #[only_auth]
     pub fn set_zro_fee_lib(env: &Env, zro_fee_lib: &Option<Address>) {
         TreasuryStorage::set_or_remove_zro_fee_lib(env, zro_fee_lib);
-        ZROFeeLibSet { zro_fee_lib: zro_fee_lib.clone() }.publish(env);
+        ZroFeeLibSet { zro_fee_lib: zro_fee_lib.clone() }.publish(env);
     }
 
     /// Withdraws any token (including native XLM) from the contract to a specified address.
@@ -65,11 +64,9 @@ impl Treasury {
     /// * `token` - The token contract address (can be native XLM or any other token)
     /// * `to` - The recipient address
     /// * `amount` - The amount to withdraw (must be positive)
-    #[only_owner]
+    #[only_auth]
     pub fn withdraw_token(env: &Env, token: &Address, to: &Address, amount: i128) {
-        let token_client = Client::new(env, token);
-        token_client.transfer(&env.current_contract_address(), to, &amount);
-
+        Client::new(env, token).transfer(&env.current_contract_address(), to, &amount);
         TokenWithdrawn { token: token.clone(), to: to.clone(), amount }.publish(env);
     }
 
@@ -79,12 +76,12 @@ impl Treasury {
 
     /// Returns the native fee percentage in basis points.
     pub fn native_fee_bp(env: &Env) -> u32 {
-        TreasuryStorage::native_fee_bp(env).unwrap_or(0)
+        TreasuryStorage::native_fee_bp(env)
     }
 
     /// Returns whether fee collection is enabled.
     pub fn fee_enabled(env: &Env) -> bool {
-        TreasuryStorage::fee_enabled(env).unwrap_or(false)
+        TreasuryStorage::fee_enabled(env)
     }
 
     /// Returns the ZRO fee library address if set.
@@ -102,9 +99,9 @@ impl Treasury {
     }
 
     /// Returns the ZRO fee library client, panics if not set.
-    fn expect_zro_fee_lib_client(env: &Env) -> ZROFeeLibClient<'static> {
-        let fee_lib = Self::zro_fee_lib(env).unwrap_or_panic(env, TreasuryError::ZROFeeLibNotSet);
-        ZROFeeLibClient::new(env, &fee_lib)
+    fn expect_zro_fee_lib_client(env: &Env) -> ZroFeeLibClient<'static> {
+        let fee_lib = Self::zro_fee_lib(env).unwrap_or_panic(env, TreasuryError::ZroFeeLibNotSet);
+        ZroFeeLibClient::new(env, &fee_lib)
     }
 }
 
@@ -125,13 +122,13 @@ impl ILayerZeroTreasury for Treasury {
         }
 
         let native_treasury_fee = Self::calculate_native_fee(env, total_native_fee);
-        if pay_in_zro {
-            let zro_fee =
-                Self::expect_zro_fee_lib_client(env).get_fee(sender, &dst_eid, &total_native_fee, &native_treasury_fee);
-            assert_with_error!(env, zro_fee >= 0, TreasuryError::InvalidZROFee);
-            zro_fee
-        } else {
-            native_treasury_fee
+        if !pay_in_zro {
+            return native_treasury_fee;
         }
+
+        let zro_fee =
+            Self::expect_zro_fee_lib_client(env).get_fee(sender, &dst_eid, &total_native_fee, &native_treasury_fee);
+        assert_with_error!(env, zro_fee >= 0, TreasuryError::InvalidZroFee);
+        zro_fee
     }
 }

package/contracts/message-libs/uln-302/Cargo.toml

@@ -6,7 +6,7 @@ license.workspace = true
 publish = false
 
 [lib]
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "rlib"]
 doctest = false
 
 [features]

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

@@ -15,13 +15,8 @@ pub enum Uln302Error {
     InvalidOptionalDVNCount,
     InvalidOptionalDVNs,
     InvalidOptionalDVNThreshold,
-    InvalidPacketHeader,
     InvalidRequiredDVNCount,
     InvalidRequiredDVNs,
-    OAppExecutorConfigNotFound,
-    OAppReceiveUlnConfigNotFound,
-    OAppSendUlnConfigNotFound,
-    OnlyEndpoint,
     UlnAtLeastOneDVN,
     UnsupportedEid,
     Verifying,

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

@@ -17,7 +17,7 @@ pub struct ExecutorConfigSet {
 
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct UlnSendConfigSet {
+pub struct SendUlnConfigSet {
     #[topic]
     pub sender: Address,
     #[topic]
@@ -27,7 +27,7 @@ pub struct UlnSendConfigSet {
 
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct UlnReceiveConfigSet {
+pub struct ReceiveUlnConfigSet {
     #[topic]
     pub receiver: Address,
     #[topic]
@@ -37,19 +37,19 @@ pub struct UlnReceiveConfigSet {
 
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct DefaultExecutorConfigSet {
+pub struct DefaultExecutorConfigsSet {
     pub params: Vec<SetDefaultExecutorConfigParam>,
 }
 
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct DefaultUlnSendConfigSet {
+pub struct DefaultSendUlnConfigsSet {
     pub params: Vec<SetDefaultUlnConfigParam>,
 }
 
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct DefaultUlnReceiveConfigSet {
+pub struct DefaultReceiveUlnConfigsSet {
     pub params: Vec<SetDefaultUlnConfigParam>,
 }
 
@@ -64,7 +64,6 @@ pub struct ExecutorFeePaid {
 #[contractevent]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct DVNFeePaid {
-    #[topic]
     pub dvns: Vec<Address>,
     pub fees: Vec<FeeRecipient>,
 }

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

@@ -1,4 +1,15 @@
-use super::*;
+use super::{Uln302, Uln302Args, Uln302Client};
+use crate::{
+    errors::Uln302Error,
+    events::{DefaultReceiveUlnConfigsSet, PayloadVerified, ReceiveUlnConfigSet},
+    interfaces::{IReceiveUln302, OAppUlnConfig, SetDefaultUlnConfigParam, UlnConfig},
+    storage::UlnStorage,
+};
+use common_macros::{contract_impl, only_auth};
+use endpoint_v2::{util, LayerZeroEndpointV2Client, Origin};
+use message_lib_common::packet_codec_v1::{self, PacketHeader};
+use soroban_sdk::{address_payload::AddressPayload, assert_with_error, Address, Bytes, BytesN, Env, Vec};
+use utils::option_ext::OptionExt;
 
 // ============================================================================================
 // IReceiveUln302 Contract Implementation
@@ -30,7 +41,8 @@ impl IReceiveUln302 for Uln302 {
     /// (all required DVNs + optional DVN threshold). Once verified, cleans up DVN confirmation
     /// storage and calls the endpoint to mark the message as verified and executable.
     fn commit_verification(env: &Env, packet_header: &Bytes, payload_hash: &BytesN<32>) {
-        let (header, header_hash, uln_config) = Self::validate_and_extract_param(env, packet_header);
+        let (header, uln_config) = Self::decode_packet_header_with_config(env, packet_header);
+        let header_hash = util::keccak256(env, packet_header);
 
         // check if the message is verifiable
         assert_with_error!(
@@ -45,10 +57,12 @@ impl IReceiveUln302 for Uln302 {
         });
 
         // commit verification to the endpoint
-        let send_lib = env.current_contract_address();
-        let origin = Origin { src_eid: header.src_eid, sender: header.sender, nonce: header.nonce };
-        let receiver = Address::from_payload(env, AddressPayload::ContractIdHash(header.receiver));
-        LayerZeroEndpointV2Client::new(env, &Self::endpoint(env)).verify(&send_lib, &origin, &receiver, payload_hash);
+        LayerZeroEndpointV2Client::new(env, &Self::endpoint(env)).verify(
+            &env.current_contract_address(),
+            &Origin { src_eid: header.src_eid, sender: header.sender, nonce: header.nonce },
+            &Address::from_payload(env, AddressPayload::ContractIdHash(header.receiver)),
+            payload_hash,
+        );
     }
 
     // ============================================================================================
@@ -58,14 +72,13 @@ impl IReceiveUln302 for Uln302 {
     /// Sets default receive ULN configurations for multiple source endpoints.
     ///
     /// Validates each config and stores it as the default for the specified source EID.
-    #[only_owner]
+    #[only_auth]
     fn set_default_receive_uln_configs(env: &Env, params: &Vec<SetDefaultUlnConfigParam>) {
         for param in params {
             param.config.validate_default_config(env);
             UlnStorage::set_default_receive_uln_configs(env, param.eid, &param.config);
         }
-
-        DefaultUlnReceiveConfigSet { params: params.clone() }.publish(env);
+        DefaultReceiveUlnConfigsSet { params: params.clone() }.publish(env);
     }
 
     // ============================================================================================
@@ -79,8 +92,8 @@ impl IReceiveUln302 for Uln302 {
 
     /// Checks if a message has been sufficiently verified by DVNs and is ready to commit.
     fn verifiable(env: &Env, packet_header: &Bytes, payload_hash: &BytesN<32>) -> bool {
-        let (_, header_hash, uln_config) = Self::validate_and_extract_param(env, packet_header);
-        Self::verifiable_internal(env, &uln_config, &header_hash, payload_hash)
+        let (_, uln_config) = Self::decode_packet_header_with_config(env, packet_header);
+        Self::verifiable_internal(env, &uln_config, &util::keccak256(env, packet_header), payload_hash)
     }
 
     /// Returns the default receive ULN configuration for a source endpoint.
@@ -95,13 +108,14 @@ impl IReceiveUln302 for Uln302 {
 
     /// Returns the effective receive ULN configuration by merging OApp config with defaults.
     fn effective_receive_uln_config(env: &Env, receiver: &Address, src_eid: u32) -> UlnConfig {
-        let default_config = Self::expect_default_receive_uln_config(env, src_eid);
+        let default_config = Self::default_receive_uln_config(env, src_eid)
+            .unwrap_or_panic(env, Uln302Error::DefaultReceiveUlnConfigNotFound);
         let oapp_config = Self::oapp_receive_uln_config(env, receiver, src_eid).unwrap_or(OAppUlnConfig::default(env));
 
-        let config = oapp_config.apply_default_config(&default_config);
-        config.validate_at_least_one_dvn(env); // validate the final config
+        let effective_config = oapp_config.apply_default_config(&default_config);
+        effective_config.validate_at_least_one_dvn(env); // validate the final config
 
-        config
+        effective_config
     }
 }
 
@@ -112,12 +126,6 @@ impl IReceiveUln302 for Uln302 {
 impl Uln302 {
     /// Sets OApp-specific receive ULN config.
     ///
-    /// # Arguments
-    /// * `receiver` - The receiver OApp address
-    /// * `src_eid` - The source endpoint ID
-    /// * `config` - The OApp-specific receive ULN configuration
-    ///
-    /// # Panics
     /// Panics if the final effective config is invalid.
     pub(super) fn set_receive_uln_config(env: &Env, receiver: &Address, src_eid: u32, config: &OAppUlnConfig) {
         config.validate_oapp_config(env);
@@ -126,15 +134,15 @@ impl Uln302 {
         // validate the config by getting the effective config
         let _ = Self::effective_receive_uln_config(env, receiver, src_eid);
 
-        UlnReceiveConfigSet { receiver: receiver.clone(), src_eid, config: config.clone() }.publish(env);
+        ReceiveUlnConfigSet { receiver: receiver.clone(), src_eid, config: config.clone() }.publish(env);
     }
 
     // ============================================================================================
     // Verification Helpers Functions
     // ============================================================================================
 
-    /// Validates packet header and extracts header, header hash, and effective ULN config.
-    fn validate_and_extract_param(env: &Env, packet_header: &Bytes) -> (PacketHeader, BytesN<32>, UlnConfig) {
+    /// Decodes packet header and returns header and effective ULN config.
+    fn decode_packet_header_with_config(env: &Env, packet_header: &Bytes) -> (PacketHeader, UlnConfig) {
         let header = packet_codec_v1::decode_packet_header(env, packet_header);
         assert_with_error!(
             env,
@@ -142,25 +150,15 @@ impl Uln302 {
             Uln302Error::InvalidEID
         );
 
-        let header_hash = util::keccak256(env, packet_header);
-        let uln_config = Self::effective_receive_uln_config(
-            env,
-            &Address::from_payload(env, AddressPayload::ContractIdHash(header.receiver.clone())),
-            header.src_eid,
-        );
+        let receiver = Address::from_payload(env, AddressPayload::ContractIdHash(header.receiver.clone()));
+        let uln_config = Self::effective_receive_uln_config(env, &receiver, header.src_eid);
 
-        (header, header_hash, uln_config)
+        (header, uln_config)
     }
 
     /// Checks if all required DVNs verified and optional DVN threshold is met.
     ///
-    /// # Arguments
-    /// * `uln_config` - The effective ULN configuration
-    /// * `header_hash` - The hash of the packet header
-    /// * `payload_hash` - The hash of the message payload
-    ///
-    /// # Returns
-    /// True if the message has been verified by enough DVNs to be committed, false otherwise
+    /// Returns true if the message has been verified by enough DVNs to be committed, false otherwise
     fn verifiable_internal(
         env: &Env,
         uln_config: &UlnConfig,
@@ -177,14 +175,7 @@ impl Uln302 {
 
     /// Checks if a DVN has submitted enough confirmations for the message.
     ///
-    /// # Arguments
-    /// * `dvn` - The DVN address
-    /// * `header_hash` - The hash of the packet header
-    /// * `payload_hash` - The hash of the message payload
-    /// * `confirmations` - The number of block confirmations the DVN has observed
-    ///
-    /// # Returns
-    /// True if the DVN has submitted enough confirmations for the message, false otherwise
+    /// Returns true if the DVN has submitted enough confirmations for the message, false otherwise
     fn verified(
         env: &Env,
         dvn: &Address,
@@ -194,14 +185,4 @@ impl Uln302 {
     ) -> bool {
         Self::confirmations(env, dvn, header_hash, payload_hash).map(|c| c >= confirmations).unwrap_or(false)
     }
-
-    // ============================================================================================
-    // Helper Functions
-    // ============================================================================================
-
-    /// Returns default receive ULN config or panics if not found.
-    fn expect_default_receive_uln_config(env: &Env, src_eid: u32) -> UlnConfig {
-        Self::default_receive_uln_config(env, src_eid)
-            .unwrap_or_panic(env, Uln302Error::DefaultReceiveUlnConfigNotFound)
-    }
 }