@layerzerolabs/protocol-stellar-v2 0.2.15 → 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, ownable, 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 soroban_sdk::{address_payload::AddressPayload, panic_with_error, vec, Address, Bytes, BytesN, Env, Vec};
 
-#[contract]
-#[ttl_configurable]
-#[ownable]
+#[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,6 +4,6 @@ use common_macros::contract_error;
 pub enum TreasuryError {
     InvalidNativeFeeBp,
     InvalidTotalNativeFee,
-    InvalidZROFee,
-    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/storage.rs

@@ -15,5 +15,5 @@ pub enum TreasuryStorage {
 
     /// 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,20 +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, ownable, 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]
-#[ownable]
+#[lz_contract]
 pub struct Treasury;
 
 #[contract_impl]
@@ -31,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);
@@ -42,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);
@@ -52,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.
@@ -66,7 +64,7 @@ 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) {
         Client::new(env, token).transfer(&env.current_contract_address(), to, &amount);
         TokenWithdrawn { token: token.clone(), to: to.clone(), amount }.publish(env);
@@ -101,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)
     }
 }
 
@@ -130,7 +128,7 @@ impl ILayerZeroTreasury for Treasury {
 
         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);
+        assert_with_error!(env, zro_fee >= 0, TreasuryError::InvalidZroFee);
         zro_fee
     }
 }

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
@@ -61,7 +72,7 @@ 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);

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

@@ -1,4 +1,24 @@
-use super::*;
+use super::{Uln302, Uln302Args, Uln302Client};
+use crate::{
+    errors::Uln302Error,
+    events::{
+        DVNFeePaid, DefaultExecutorConfigsSet, DefaultSendUlnConfigsSet, ExecutorConfigSet, ExecutorFeePaid,
+        SendUlnConfigSet,
+    },
+    interfaces::{
+        ExecutorConfig, ISendUln302, OAppExecutorConfig, OAppUlnConfig, SetDefaultExecutorConfigParam,
+        SetDefaultUlnConfigParam, UlnConfig,
+    },
+    storage::UlnStorage,
+};
+use common_macros::{contract_impl, only_auth};
+use endpoint_v2::{FeeRecipient, FeesAndPacket, ISendLib, MessagingFee, OutboundPacket};
+use message_lib_common::{
+    interfaces::{LayerZeroDVNClient, LayerZeroExecutorClient, LayerZeroTreasuryClient},
+    packet_codec_v1, worker_options,
+};
+use soroban_sdk::{assert_with_error, bytes, vec, Address, Bytes, BytesN, Env, Map, Vec};
+use utils::option_ext::OptionExt;
 
 // ==============================================================================
 // ISendLib Contract Implementation
@@ -96,7 +116,7 @@ impl ISendLib for Uln302 {
 #[contract_impl]
 impl ISendUln302 for Uln302 {
     /// Sets default executor configurations for multiple destination endpoints.
-    #[only_owner]
+    #[only_auth]
     fn set_default_executor_configs(env: &Env, params: &Vec<SetDefaultExecutorConfigParam>) {
         for param in params {
             param.config.validate_default_config(env);
@@ -106,7 +126,7 @@ impl ISendUln302 for Uln302 {
     }
 
     /// Sets default send ULN configurations for multiple destination endpoints.
-    #[only_owner]
+    #[only_auth]
     fn set_default_send_uln_configs(env: &Env, params: &Vec<SetDefaultUlnConfigParam>) {
         for param in params {
             param.config.validate_default_config(env);

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

@@ -1,30 +1,14 @@
 use crate::{
     errors::Uln302Error,
-    events::{
-        DVNFeePaid, DefaultExecutorConfigsSet, DefaultReceiveUlnConfigsSet, DefaultSendUlnConfigsSet,
-        ExecutorConfigSet, ExecutorFeePaid, PayloadVerified, ReceiveUlnConfigSet, SendUlnConfigSet,
-    },
-    interfaces::{
-        ExecutorConfig, IReceiveUln302, ISendUln302, OAppExecutorConfig, OAppUlnConfig, SetDefaultExecutorConfigParam,
-        SetDefaultUlnConfigParam, UlnConfig,
-    },
+    interfaces::{IReceiveUln302, ISendUln302},
     storage::UlnStorage,
 };
-use common_macros::{contract_impl, only_owner, ownable, ttl_configurable};
-use endpoint_v2::{
-    util, FeeRecipient, FeesAndPacket, IMessageLib, ISendLib, LayerZeroEndpointV2Client, MessageLibType,
-    MessageLibVersion, MessagingFee, Origin, OutboundPacket, SetConfigParam,
-};
-use message_lib_common::{
-    interfaces::{LayerZeroDVNClient, LayerZeroExecutorClient, LayerZeroTreasuryClient},
-    packet_codec_v1::{self, PacketHeader},
-    worker_options,
-};
+use common_macros::{contract_impl, lz_contract};
+use endpoint_v2::{IMessageLib, MessageLibType, MessageLibVersion, SetConfigParam};
 use soroban_sdk::{
-    address_payload::AddressPayload,
-    assert_with_error, bytes, contract, panic_with_error, vec,
+    assert_with_error, panic_with_error,
     xdr::{FromXdr, ToXdr},
-    Address, Bytes, BytesN, Env, Map, Vec,
+    Address, Bytes, Env, Vec,
 };
 use utils::option_ext::OptionExt;
 
@@ -32,9 +16,7 @@ pub const CONFIG_TYPE_EXECUTOR: u32 = 1;
 pub const CONFIG_TYPE_SEND_ULN: u32 = 2;
 pub const CONFIG_TYPE_RECEIVE_ULN: u32 = 3;
 
-#[contract]
-#[ttl_configurable]
-#[ownable]
+#[lz_contract]
 pub struct Uln302;
 
 #[contract_impl]

package/contracts/oapps/counter/Cargo.toml

@@ -22,4 +22,17 @@ assert_unordered = "0.3.5"
 simple-message-lib = { workspace = true }
 message-lib-common = { workspace = true, features = ["testutils"] }
 endpoint-v2 = { workspace = true, features = ["testutils"] }
-executor = { workspace = true, features = ["testutils"] }
+executor = { workspace = true, features = ["testutils"] }
+uln302 = { workspace = true, features = ["testutils"] }
+dvn = { workspace = true, features = ["testutils"] }
+dvn-fee-lib = { workspace = true }
+executor-fee-lib = { workspace = true }
+worker = { workspace = true }
+treasury = { workspace = true, features = ["testutils"] }
+price-feed = { workspace = true }
+executor-helper = { workspace = true }
+# For real DVN signature verification in integration tests
+k256 = "0.13"
+sha3 = "0.10"
+rand = "0.8"
+ed25519-dalek = "2"

package/contracts/oapps/counter/integration_tests/mod.rs

@@ -1,3 +1,6 @@
-mod setup;
+mod setup_sml;
+mod setup_uln;
+mod signing;
 mod test_with_sml;
+mod test_with_uln;
 mod utils;

package/contracts/oapps/counter/integration_tests/{setup.rs → setup_sml.rs}

@@ -2,17 +2,17 @@ extern crate std;
 
 use crate::{
     counter::{Counter, CounterClient},
-    integration_tests::utils::address_to_bytes32,
+    integration_tests::utils::{
+        address_to_bytes32, decode_packet, register_library, set_peer, set_zro, ChainSetupCommon,
+    },
 };
-use endpoint_v2::{EndpointV2, EndpointV2Client};
+use endpoint_v2::{EndpointV2, EndpointV2Client, OutboundPacket};
+use message_lib_common::packet_codec_v1;
 use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
 use soroban_sdk::{
-    address_payload::AddressPayload,
-    log,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, BytesN, Env, IntoVal,
+    Address, Bytes, Env, IntoVal,
 };
-use utils::buffer_reader::BufferReader;
 
 pub struct ChainSetup<'a> {
     pub eid: u32,
@@ -23,6 +23,38 @@ pub struct ChainSetup<'a> {
     pub counter: CounterClient<'a>,
 }
 
+impl<'a> ChainSetupCommon<'a> for ChainSetup<'a> {
+    fn counter(&self) -> &CounterClient<'a> {
+        &self.counter
+    }
+    fn endpoint(&self) -> &EndpointV2Client<'a> {
+        &self.endpoint
+    }
+    fn native_token(&self) -> &Address {
+        &self.native_token
+    }
+    fn owner(&self) -> &Address {
+        &self.owner
+    }
+    fn validate_packet(&self, env: &Env, packet_event: &(Bytes, Bytes, Address)) -> OutboundPacket {
+        let packet = decode_packet(env, &packet_event.0);
+        let encoded_header = packet_codec_v1::encode_packet_header(env, &packet);
+        let payload_hash = packet_codec_v1::payload_hash(env, &packet);
+
+        env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.sml.address,
+                fn_name: "validate_packet",
+                args: (&encoded_header, &payload_hash).into_val(env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.sml.validate_packet(&encoded_header, &payload_hash);
+        packet
+    }
+}
+
 pub struct TestSetup<'a> {
     pub env: Env,
 
@@ -31,7 +63,7 @@ pub struct TestSetup<'a> {
 }
 
 fn setup_chain<'a>(env: &Env, owner: &Address) -> ChainSetup<'a> {
-    // Create ZRO token
+    // Create ZRO token for endpoint fees
     let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let zro_token = zro_sac.address();
 
@@ -44,19 +76,8 @@ fn setup_chain<'a>(env: &Env, owner: &Address) -> ChainSetup<'a> {
     let sml = SimpleMessageLibClient::new(env, &sml_address);
     let counter = CounterClient::new(env, &counter_address);
 
-    // Set ZRO token in endpoint
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_address,
-            fn_name: "set_zro",
-            args: (&zro_token,).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint.set_zro(&zro_token);
-
-    register_library(env, &owner, &endpoint, &sml.address);
+    set_zro(env, owner, &endpoint, &zro_token);
+    register_library(env, owner, &endpoint, &sml.address);
 
     let eid = endpoint.eid();
     let native_token = endpoint.native_token();
@@ -66,25 +87,20 @@ fn setup_chain<'a>(env: &Env, owner: &Address) -> ChainSetup<'a> {
 pub fn setup<'a>() -> TestSetup<'a> {
     let env = Env::default();
     let owner = Address::generate(&env);
-    let sac = env.register_stellar_asset_contract_v2(owner.clone());
-    log!(&env, "native_token: {:?}", sac.address());
 
     let chain_a = setup_chain(&env, &owner);
     let chain_b = setup_chain(&env, &owner);
 
-    log!(&env, "endpoint_a: {:?}", chain_a.endpoint.address);
-    log!(&env, "native_token_a: {:?}", chain_a.native_token);
-    log!(&env, "counter_a: {:?}", chain_a.counter.address);
-    log!(&env, "sml_a: {:?}", chain_a.sml.address);
-
-    log!(&env, "endpoint_b: {:?}", chain_b.endpoint.address);
-    log!(&env, "native_token_b: {:?}", chain_b.native_token);
-    log!(&env, "counter_b: {:?}", chain_b.counter.address);
-    log!(&env, "sml_b: {:?}", chain_b.sml.address);
-
     TestSetup { env, chain_a, chain_b }
 }
 
+pub fn wired_setup<'a>() -> TestSetup<'a> {
+    let test_setup = setup();
+    wire_endpoint(&test_setup.env, &[&test_setup.chain_a, &test_setup.chain_b]);
+    wire_counter(&test_setup.env, &[&test_setup.chain_a, &test_setup.chain_b]);
+    test_setup
+}
+
 pub fn wire_endpoint(env: &Env, chains: &[&ChainSetup<'_>]) {
     for chain in chains {
         for other_chain in chains {
@@ -114,33 +130,6 @@ pub fn wire_counter(env: &Env, chains: &[&ChainSetup<'_>]) {
     }
 }
 
-pub fn set_peer(env: &Env, owner: &Address, counter: &CounterClient<'_>, dst_eid: u32, peer: &BytesN<32>) {
-    let peer_option = Some(peer.clone());
-    env.mock_auths(&[MockAuth {
-        address: owner,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "set_peer",
-            args: (&dst_eid, &peer_option).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    counter.set_peer(&dst_eid, &peer_option);
-}
-
-pub fn register_library(env: &Env, owner: &Address, endpoint: &EndpointV2Client<'_>, lib: &Address) {
-    env.mock_auths(&[MockAuth {
-        address: owner,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint.address,
-            fn_name: "register_library",
-            args: (lib,).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint.register_library(lib);
-}
-
 pub fn set_default_send_library(
     env: &Env,
     owner: &Address,
@@ -178,24 +167,3 @@ pub fn set_default_receive_library(
     }]);
     endpoint.set_default_receive_library(&src_eid, lib, &0u64);
 }
-
-pub fn decode_packet(env: &Env, encoded_packet: &soroban_sdk::Bytes) -> endpoint_v2::OutboundPacket {
-    use message_lib_common::packet_codec_v1::*;
-
-    let header = decode_packet_header(env, &encoded_packet.slice(0..HEADER_LENGTH));
-    let payload = encoded_packet.slice(HEADER_LENGTH..);
-
-    let mut payload_reader = BufferReader::new(&payload);
-    let guid = payload_reader.read_bytes_n::<32>();
-    let message = payload_reader.read_bytes_until_end();
-
-    endpoint_v2::OutboundPacket {
-        nonce: header.nonce,
-        src_eid: header.src_eid,
-        sender: Address::from_payload(env, AddressPayload::ContractIdHash(header.sender)),
-        dst_eid: header.dst_eid,
-        receiver: header.receiver,
-        guid,
-        message,
-    }
-}