@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

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,10 +5,12 @@ 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

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

@@ -4,7 +4,7 @@ use crate::{
     interfaces::ZROFeeLibClient,
     storage::TreasuryStorage,
 };
-use common_macros::{contract_impl, only_owner, ttl_configurable};
+use common_macros::{contract_impl, only_owner, ownable, ttl_configurable};
 use message_lib_common::interfaces::ILayerZeroTreasury;
 use soroban_sdk::{assert_with_error, contract, token::Client, Address, Env};
 use utils::option_ext::OptionExt;
@@ -14,6 +14,7 @@ const BPS_DENOMINATOR: u32 = 10000;
 
 #[contract]
 #[ttl_configurable]
+#[ownable]
 pub struct Treasury;
 
 #[contract_impl]
@@ -67,9 +68,7 @@ impl Treasury {
     /// * `amount` - The amount to withdraw (must be positive)
     #[only_owner]
     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 +78,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.
@@ -125,13 +124,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

@@ -30,7 +30,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 +46,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,
+        );
     }
 
     // ============================================================================================
@@ -64,8 +67,7 @@ impl IReceiveUln302 for Uln302 {
             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 +81,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 +97,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 +115,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 +123,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 +139,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 +164,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 +174,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)
-    }
 }