@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

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

@@ -17,7 +17,9 @@ 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 soroban_sdk::{
+    address_payload::AddressPayload, assert_with_error, bytes, vec, Address, Bytes, BytesN, Env, Map, Vec,
+};
 use utils::option_ext::OptionExt;
 
 // ==============================================================================
@@ -101,11 +103,11 @@ impl ISendLib for Uln302 {
         let mut zro_fee_recipients = vec![env];
         if treasury_fee != 0 {
             // The treasury contract address is used as the fixed fee recipient (rather than allowing
-            // the treasury admin to configure a custom receiver). This is because ZRO may be issued
-            // as a Stellar Classic Asset, which requires the recipient to have an established trustline.
-            // If an arbitrary receiver could be configured, a malicious treasury admin could set it to
-            // an address without a trustline, causing all token transfers to fail and effectively
-            // DOSing the OApp. Using the contract address ensures the recipient is always valid.
+            // the treasury admin to configure a custom receiver). This is because a malicious treasury
+            // admin could set the recipient to an address that has not been created/initialized on Stellar.
+            // On Stellar, uninitialized accounts cannot receive any tokens, including native XLM. This
+            // would cause all fee payments to fail, effectively DOSing the OApp. Using the contract
+            // address ensures the recipient is always valid and can receive tokens.
             let treasury_fee_recipient = FeeRecipient { to: treasury_addr, amount: treasury_fee };
             if pay_in_zro {
                 zro_fee_recipients.push_back(treasury_fee_recipient);
@@ -338,6 +340,13 @@ fn prepare_packet_and_options(
     packet: &OutboundPacket,
     options: &Bytes,
 ) -> (Bytes, Map<u32, Bytes>, Bytes, BytesN<32>) {
+    // Only allow contract addresses (C-addresses) as senders
+    assert_with_error!(
+        env,
+        matches!(packet.sender.to_payload(), Some(AddressPayload::ContractIdHash(_))),
+        Uln302Error::InvalidSenderAddress
+    );
+
     let (executor_options, dvn_options) = worker_options::split_worker_options(env, options);
     let packet_header = packet_codec_v1::encode_packet_header(env, packet);
     let payload_hash = packet_codec_v1::payload_hash(env, packet);

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

@@ -5,23 +5,23 @@ use soroban_sdk::{Address, BytesN};
 /// Storage for the Uln302 message library.
 #[storage]
 pub enum UlnStorage {
-    /// The endpoint address
+    /// The endpoint address (set in constructor)
     #[instance(Address)]
     Endpoint,
 
-    /// The treasury address
+    /// The treasury address for fee collection (set in constructor)
     #[instance(Address)]
     Treasury,
 
-    /// The default executor configurations for a destination endpoint
+    /// The default executor configurations for a destination endpoint.
     #[persistent(ExecutorConfig)]
     DefaultExecutorConfigs { dst_eid: u32 },
 
-    /// The default send ULN configurations for a destination endpoint
+    /// The default send ULN configurations for a destination endpoint.
     #[persistent(UlnConfig)]
     DefaultSendUlnConfigs { dst_eid: u32 },
 
-    /// The default receive ULN configurations for a source endpoint
+    /// The default receive ULN configurations for a source endpoint.
     #[persistent(UlnConfig)]
     DefaultReceiveUlnConfigs { src_eid: u32 },
 

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

@@ -0,0 +1,71 @@
+extern crate std;
+
+use soroban_sdk::{testutils::Address as _, xdr::FromXdr, Address};
+
+use crate::{
+    errors::Uln302Error,
+    interfaces::{ExecutorConfig, UlnConfig},
+    tests::setup::{setup, TestSetup},
+    uln302::{CONFIG_TYPE_EXECUTOR, CONFIG_TYPE_RECEIVE_ULN, CONFIG_TYPE_SEND_ULN},
+};
+
+#[test]
+fn test_get_config_invalid_config_type_should_fail() {
+    let setup = setup();
+    let eid = 100u32;
+
+    // Must set defaults so the EID is considered supported.
+    setup.set_default_configs(eid, UlnConfig::generate(&setup.env, 10, 1, 0, 0));
+
+    let TestSetup { env, uln302, .. } = setup;
+    let oapp = Address::generate(&env);
+
+    let invalid_config_type = 999u32;
+    let res = uln302.try_get_config(&eid, &oapp, &invalid_config_type);
+    assert_eq!(res.err().unwrap().ok().unwrap(), Uln302Error::InvalidConfigType.into());
+}
+
+#[test]
+fn test_get_config_executor_returns_effective_executor_config_xdr() {
+    let setup = setup();
+    let eid = 100u32;
+    setup.set_default_configs(eid, UlnConfig::generate(&setup.env, 10, 1, 0, 0));
+
+    let TestSetup { env, uln302, .. } = setup;
+    let oapp = Address::generate(&env);
+
+    let xdr = uln302.get_config(&eid, &oapp, &CONFIG_TYPE_EXECUTOR);
+    let decoded = ExecutorConfig::from_xdr(&env, &xdr).ok().unwrap();
+
+    assert_eq!(decoded, uln302.effective_executor_config(&oapp, &eid));
+}
+
+#[test]
+fn test_get_config_send_uln_returns_effective_send_uln_config_xdr() {
+    let setup = setup();
+    let eid = 100u32;
+    setup.set_default_configs(eid, UlnConfig::generate(&setup.env, 10, 1, 0, 0));
+
+    let TestSetup { env, uln302, .. } = setup;
+    let oapp = Address::generate(&env);
+
+    let xdr = uln302.get_config(&eid, &oapp, &CONFIG_TYPE_SEND_ULN);
+    let decoded = UlnConfig::from_xdr(&env, &xdr).ok().unwrap();
+
+    assert_eq!(decoded, uln302.effective_send_uln_config(&oapp, &eid));
+}
+
+#[test]
+fn test_get_config_receive_uln_returns_effective_receive_uln_config_xdr() {
+    let setup = setup();
+    let eid = 100u32;
+    setup.set_default_configs(eid, UlnConfig::generate(&setup.env, 10, 1, 0, 0));
+
+    let TestSetup { env, uln302, .. } = setup;
+    let oapp = Address::generate(&env);
+
+    let xdr = uln302.get_config(&eid, &oapp, &CONFIG_TYPE_RECEIVE_ULN);
+    let decoded = UlnConfig::from_xdr(&env, &xdr).ok().unwrap();
+
+    assert_eq!(decoded, uln302.effective_receive_uln_config(&oapp, &eid));
+}

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

@@ -1,4 +1,5 @@
 mod get_app_receive_uln_config;
 mod get_app_send_uln_config;
+mod get_config;
 mod get_oapp_executor_config;
 mod set_config;

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

@@ -12,8 +12,11 @@ use soroban_sdk::{
 };
 use utils::option_ext::OptionExt;
 
+/// Configuration type for executor settings (max message size, executor address)
 pub const CONFIG_TYPE_EXECUTOR: u32 = 1;
+/// Configuration type for send-side ULN settings (DVNs, confirmations)
 pub const CONFIG_TYPE_SEND_ULN: u32 = 2;
+/// Configuration type for receive-side ULN settings (DVNs, confirmations)
 pub const CONFIG_TYPE_RECEIVE_ULN: u32 = 3;
 
 #[lz_contract]

package/contracts/oapps/counter/Cargo.toml

@@ -18,7 +18,9 @@ oapp-macros = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }
 simple-message-lib = { workspace = true }
+blocked-message-lib = { workspace = true }
 message-lib-common = { workspace = true, features = ["testutils"] }
 endpoint-v2 = { workspace = true, features = ["testutils"] }
 executor = { workspace = true, features = ["testutils"] }

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

@@ -1,6 +1,7 @@
 mod setup_sml;
 mod setup_uln;
 mod signing;
+mod test_with_blocked;
 mod test_with_sml;
 mod test_with_uln;
 mod utils;

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

@@ -63,11 +63,16 @@ pub struct TestSetup<'a> {
 }
 
 fn setup_chain<'a>(env: &Env, owner: &Address) -> ChainSetup<'a> {
+    // Create native token for endpoint fees
+    let native_sac = env.register_stellar_asset_contract_v2(owner.clone());
+    let native_token = native_sac.address();
+
     // Create ZRO token for endpoint fees
     let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let zro_token = zro_sac.address();
 
-    let endpoint_address = env.register(EndpointV2, (owner,));
+    let eid: u32 = 30400; // Test EID
+    let endpoint_address = env.register(EndpointV2, (owner, eid, &native_token));
     let fee_recipient = Address::generate(env);
     let sml_address = env.register(SimpleMessageLib, (owner, &endpoint_address, &fee_recipient));
     let counter_address = env.register(Counter, (owner, &endpoint_address, owner));
@@ -78,9 +83,6 @@ fn setup_chain<'a>(env: &Env, owner: &Address) -> ChainSetup<'a> {
 
     set_zro(env, owner, &endpoint, &zro_token);
     register_library(env, owner, &endpoint, &sml.address);
-
-    let eid = endpoint.eid();
-    let native_token = endpoint.native_token();
     ChainSetup { owner: owner.clone(), endpoint, sml, counter, eid, native_token }
 }
 

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

@@ -352,6 +352,7 @@ pub struct TestSetup<'a> {
 
 /// Intermediate structure to hold chain infrastructure before DVN/Executor creation
 struct ChainInfra {
+    eid: u32,
     endpoint_address: Address,
     uln302_address: Address,
     #[allow(dead_code)]
@@ -359,6 +360,7 @@ struct ChainInfra {
     price_feed_address: Address,
     dvn_fee_lib_address: Address,
     executor_fee_lib_address: Address,
+    native_token: Address,
     zro_token: Address,
     admin: Address,
     deposit_address: Address,
@@ -368,12 +370,17 @@ struct ChainInfra {
 
 /// Phase 1: Create basic chain infrastructure (Endpoint, ULN302, Treasury, etc.)
 fn setup_chain_infrastructure(env: &Env, owner: &Address) -> ChainInfra {
+    // Create native token for endpoint fees
+    let native_sac = env.register_stellar_asset_contract_v2(owner.clone());
+    let native_token = native_sac.address();
+
     // Create ZRO token
     let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let zro_token = zro_sac.address();
 
     // Register endpoint
-    let endpoint_address = env.register(EndpointV2, (owner,));
+    let eid: u32 = 30400; // Test EID
+    let endpoint_address = env.register(EndpointV2, (owner, eid, &native_token));
 
     // Register Treasury (real)
     let treasury_address = env.register(Treasury, (owner,));
@@ -399,12 +406,14 @@ fn setup_chain_infrastructure(env: &Env, owner: &Address) -> ChainInfra {
     let dvn_credentials = DvnCredentials::generate(1);
 
     ChainInfra {
+        eid,
         endpoint_address,
         uln302_address,
         treasury_address: treasury_address.clone(),
         price_feed_address,
         dvn_fee_lib_address,
         executor_fee_lib_address,
+        native_token,
         zro_token,
         admin,
         deposit_address,
@@ -502,16 +511,14 @@ fn finalize_chain_setup<'a>(
 
     // Create clients
     let endpoint = EndpointV2Client::new(env, &infra.endpoint_address);
-
-    let native_token = endpoint.native_token();
-
     let uln302 = Uln302Client::new(env, &infra.uln302_address);
     let counter = CounterClient::new(env, &counter_address);
 
     set_zro(env, owner, &endpoint, &infra.zro_token);
     register_library(env, owner, &endpoint, &uln302.address);
 
-    let eid = endpoint.eid();
+    let eid = infra.eid;
+    let native_token = infra.native_token.clone();
 
     // Set up price feed with initial prices for this chain's eid
     setup_price_feed(env, owner, &infra.price_feed_address, eid);

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

@@ -0,0 +1,67 @@
+use crate::{
+    codec::MsgType,
+    integration_tests::{setup_sml::*, utils::*},
+};
+use blocked_message_lib::{BlockedMessageLib, BlockedMessageLibError};
+use endpoint_v2::MessagingFee;
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Bytes, IntoVal,
+};
+
+#[test]
+fn test_blocked_message_lib_quote_fails() {
+    let TestSetup { env, chain_a, chain_b } = wired_setup();
+
+    // Deploy and configure BlockedMessageLib as Chain A's send library to Chain B.
+    let blocked_lib = env.register(BlockedMessageLib, ());
+    register_library(&env, &chain_a.owner, &chain_a.endpoint, &blocked_lib);
+    set_default_send_library(&env, &chain_a.owner, &chain_a.endpoint, chain_b.eid, &blocked_lib);
+
+    let options = Bytes::new(&env);
+    let msg_type = MsgType::Vanilla as u32;
+
+    let result = chain_a.counter.try_quote(&chain_b.eid, &msg_type, &options, &false);
+    assert_eq!(result.unwrap_err().unwrap(), BlockedMessageLibError::NotImplemented.into());
+}
+
+#[test]
+fn test_blocked_message_lib_send_fails() {
+    let TestSetup { env, chain_a, chain_b } = wired_setup();
+
+    // Deploy and configure BlockedMessageLib as Chain A's send library to Chain B.
+    let blocked_lib = env.register(BlockedMessageLib, ());
+    register_library(&env, &chain_a.owner, &chain_a.endpoint, &blocked_lib);
+    set_default_send_library(&env, &chain_a.owner, &chain_a.endpoint, chain_b.eid, &blocked_lib);
+
+    let sender = Address::generate(&env);
+    let options = Bytes::new(&env);
+    let msg_type = MsgType::Vanilla as u32;
+
+    // We can't quote (blocked), so pass a zero-fee payment. The send should still fail inside the send library.
+    let fee = MessagingFee { native_fee: 0, zro_fee: 0 };
+
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain_a.counter.address,
+            fn_name: "increment",
+            args: (&sender, &chain_b.eid, &msg_type, &options, &fee).into_val(&env),
+            sub_invokes: &[MockAuthInvoke {
+                contract: &chain_a.native_token,
+                fn_name: "transfer",
+                args: (&sender, &chain_a.endpoint.address, &fee.native_fee).into_val(&env),
+                sub_invokes: &[],
+            }],
+        },
+    }]);
+
+    let result = chain_a.counter.try_increment(&sender, &chain_b.eid, &msg_type, &options, &fee);
+    assert_eq!(result.unwrap_err().unwrap(), BlockedMessageLibError::NotImplemented.into());
+
+    // Ensure no packet was emitted.
+    assert!(scan_packet_sent_event(&env, &chain_a.endpoint.address).is_none());
+
+    // State should be rolled back (outbound count unchanged).
+    assert_eq!(chain_a.counter.outbound_count(&chain_b.eid), 0);
+}

package/contracts/oapps/counter/src/tests/mod.rs

@@ -6,6 +6,7 @@ use soroban_sdk::{
 
 pub mod test_codec;
 pub mod test_counter;
+pub mod test_u256_ext;
 
 pub fn mint_to(env: &Env, owner: &Address, native_token: &Address, to: &Address, amount: i128) {
     env.mock_auths(&[MockAuth {

package/contracts/oapps/counter/src/tests/test_u256_ext.rs

@@ -0,0 +1,48 @@
+use crate::u256_ext::U256Ext;
+use soroban_sdk::{Env, U256};
+
+#[test]
+fn test_to_i128_with_small_value() {
+    let env = Env::default();
+    let val = U256::from_u128(&env, 100);
+    assert_eq!(val.to_i128(), Some(100i128));
+}
+
+#[test]
+fn test_to_i128_with_zero() {
+    let env = Env::default();
+    let val = U256::from_u128(&env, 0);
+    assert_eq!(val.to_i128(), Some(0i128));
+}
+
+#[test]
+fn test_to_i128_with_i128_max() {
+    let env = Env::default();
+    let val = U256::from_u128(&env, i128::MAX as u128);
+    assert_eq!(val.to_i128(), Some(i128::MAX));
+}
+
+#[test]
+fn test_to_i128_with_value_larger_than_i128_max_returns_none() {
+    let env = Env::default();
+    // i128::MAX + 1 should not fit in i128
+    let val = U256::from_u128(&env, (i128::MAX as u128) + 1);
+    assert_eq!(val.to_i128(), None);
+}
+
+#[test]
+fn test_to_i128_with_u128_max_returns_none() {
+    let env = Env::default();
+    let val = U256::from_u128(&env, u128::MAX);
+    assert_eq!(val.to_i128(), None);
+}
+
+#[test]
+fn test_to_i128_with_high_bits_set_returns_none() {
+    let env = Env::default();
+    // Create a U256 with high 128 bits set (value > u128::MAX)
+    // from_parts takes (hi_hi, hi_lo, lo_hi, lo_lo) where each is u64
+    // Setting hi_hi or hi_lo to non-zero makes it > u128::MAX
+    let val = U256::from_parts(&env, 1, 0, 0, 0); // Sets bits 192-255
+    assert_eq!(val.to_i128(), None);
+}

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

@@ -7,8 +7,5 @@ pub mod oapp_options_type3;
 pub mod oapp_receiver;
 pub mod oapp_sender;
 
-#[cfg(test)]
-mod macro_tests;
-
 #[cfg(test)]
 mod tests;

package/contracts/oapps/oapp/src/tests/mod.rs

@@ -2,3 +2,4 @@ mod oapp_core;
 mod oapp_options_type3;
 mod oapp_receiver;
 mod oapp_sender;
+mod test_macros;

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

@@ -76,7 +76,8 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let oft_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let oft_token = oft_sac.address();
 
-    let endpoint_address = env.register(EndpointV2, (&owner,));
+    let eid: u32 = 30400; // Test EID
+    let endpoint_address = env.register(EndpointV2, (&owner, eid, &native_token));
     let fee_recipient = Address::generate(env);
     let sml_address = env.register(SimpleMessageLib, (&owner, &endpoint_address, &fee_recipient));
     let delegate: Option<Address> = Some(owner.clone());
@@ -101,8 +102,6 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     endpoint.set_zro(&zro_token);
 
     register_library(env, &owner, &endpoint, &sml.address);
-
-    let eid = endpoint.eid();
     ChainSetup { eid, owner, native_token, zro_token, oft_token, endpoint, sml, oft, fee_collector }
 }
 

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

@@ -17,3 +17,6 @@ cfg_if::cfg_if! {
 #[cfg(test)]
 #[path = "../integration-tests/mod.rs"]
 pub mod integration_tests;
+
+#[cfg(test)]
+mod tests;

package/contracts/oapps/oft/src/tests/extensions/mod.rs

@@ -0,0 +1,3 @@
+mod oft_fee;
+mod pausable;
+mod rate_limiter;