@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

package/contracts/endpoint-v2/src/tests/messaging_composer/send_compose.rs

@@ -1,12 +1,27 @@
-use crate::{events::ComposeSent, storage, tests::endpoint_setup::setup, util::keccak256};
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Bytes, BytesN, IntoVal,
-};
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
 use utils::testing_utils::assert_event;
 
+use crate::{
+    constants::MAX_COMPOSE_INDEX, errors::EndpointError, events::ComposeSent, tests::endpoint_setup::setup,
+    tests::endpoint_setup::TestSetup, util::keccak256,
+};
+
+fn try_send_compose_with_auth(
+    context: &TestSetup,
+    from: &Address,
+    to: &Address,
+    guid: &BytesN<32>,
+    index: u32,
+    message: &Bytes,
+) -> Result<Result<(), soroban_sdk::ConversionError>, Result<soroban_sdk::Error, soroban_sdk::InvokeError>> {
+    context.mock_auth(from, "send_compose", (from, to, guid, &index, message));
+    context.endpoint_client.try_send_compose(from, to, guid, &index, message)
+}
+
+// Authorization (from must authorize)
 #[test]
-fn test_send_compose_success() {
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_send_compose_requires_from_auth() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
@@ -14,49 +29,31 @@ fn test_send_compose_success() {
     let from = Address::generate(env);
     let to = Address::generate(env);
     let guid = BytesN::from_array(env, &[1u8; 32]);
-    let index = 1u32;
-    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
-
-    // Verify initial state - compose queue should not exist
-    let initial_queue = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::compose_queue(env, &from, &to, &guid, index)
-    });
-    assert_eq!(initial_queue, None, "Initial compose queue should be None");
-
-    // Mock auth for 'from' address
-    env.mock_auths(&[MockAuth {
-        address: &from,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "send_compose",
-            args: (&from, &to, &guid, &index, &message).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+    let index = 0u32;
+    let message = Bytes::from_array(env, &[1, 2, 3]);
 
+    // No mock_auth for `from` -> should panic at `from.require_auth()`.
     endpoint_client.send_compose(&from, &to, &guid, &index, &message);
+}
 
-    // Verify the event was published
-    assert_event(
-        env,
-        &endpoint_client.address,
-        ComposeSent { from: from.clone(), to: to.clone(), guid: guid.clone(), index, message: message.clone() },
-    );
+// Index bounds (<= MAX_COMPOSE_INDEX)
+#[test]
+fn test_send_compose_fails_when_index_exceeds_max() {
+    let context = setup();
+    let env = &context.env;
 
-    // Verify the compose queue was set via public interface
-    let message_hash = keccak256(env, &message);
-    let stored_hash = endpoint_client.compose_queue(&from, &to, &guid, &index);
-    assert_eq!(stored_hash, Some(message_hash.clone()));
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let invalid_index = MAX_COMPOSE_INDEX + 1;
+    let message = Bytes::from_array(env, &[1, 2, 3]);
 
-    // Assert storage change directly
-    let stored_hash_direct = env.as_contract(&endpoint_client.address, || {
-        storage::EndpointStorage::compose_queue(env, &from, &to, &guid, index)
-    });
-    assert_eq!(stored_hash_direct, Some(message_hash), "Storage should contain the message hash in compose queue");
+    let result = try_send_compose_with_auth(&context, &from, &to, &guid, invalid_index, &message);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InvalidIndex.into());
 }
 
 #[test]
-fn test_send_compose_different_indices() {
+fn test_send_compose_succeeds_at_max_index() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
@@ -64,85 +61,43 @@ fn test_send_compose_different_indices() {
     let from = Address::generate(env);
     let to = Address::generate(env);
     let guid = BytesN::from_array(env, &[1u8; 32]);
-    let message1 = Bytes::from_array(env, &[1, 2, 3]);
-    let message2 = Bytes::from_array(env, &[4, 5, 6]);
+    let index = MAX_COMPOSE_INDEX;
+    let message = Bytes::from_array(env, &[1, 2, 3]);
 
-    // Send compose with index 0
-    env.mock_auths(&[MockAuth {
-        address: &from,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "send_compose",
-            args: (&from, &to, &guid, &0u32, &message1).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.send_compose(&from, &to, &guid, &0, &message1);
-
-    // Send compose with index 1
-    env.mock_auths(&[MockAuth {
-        address: &from,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "send_compose",
-            args: (&from, &to, &guid, &1u32, &message2).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.send_compose(&from, &to, &guid, &1, &message2);
-
-    // Verify both compose queues exist
-    let hash1 = keccak256(env, &message1);
-    let hash2 = keccak256(env, &message2);
-    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &0), Some(hash1));
-    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &1), Some(hash2));
+    context.send_compose_with_auth(&from, &to, &guid, index, &message);
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &index), Some(keccak256(env, &message)));
 }
 
+// Successful send_compose stores compose_queue and emits ComposeSent
 #[test]
-fn test_send_compose_different_guids() {
+fn test_send_compose_success() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
 
     let from = Address::generate(env);
     let to = Address::generate(env);
-    let guid1 = BytesN::from_array(env, &[1u8; 32]);
-    let guid2 = BytesN::from_array(env, &[2u8; 32]);
-    let index = 0u32;
-    let message = Bytes::from_array(env, &[1, 2, 3]);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let index = 1u32;
+    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
+
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &index), None);
+    context.send_compose_with_auth(&from, &to, &guid, index, &message);
+
+    // Verify the event was published.
+    assert_event(
+        env,
+        &endpoint_client.address,
+        ComposeSent { from: from.clone(), to: to.clone(), guid: guid.clone(), index, message: message.clone() },
+    );
 
-    // Send compose with guid1
-    env.mock_auths(&[MockAuth {
-        address: &from,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "send_compose",
-            args: (&from, &to, &guid1, &index, &message).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.send_compose(&from, &to, &guid1, &index, &message);
-
-    // Send compose with guid2
-    env.mock_auths(&[MockAuth {
-        address: &from,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "send_compose",
-            args: (&from, &to, &guid2, &index, &message).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint_client.send_compose(&from, &to, &guid2, &index, &message);
-
-    // Verify both compose queues exist
-    let message_hash = keccak256(env, &message);
-    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid1, &index), Some(message_hash.clone()));
-    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid2, &index), Some(message_hash));
+    // Verify the compose queue was set via public interface.
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &index), Some(keccak256(env, &message)));
 }
 
+// Empty message is allowed
 #[test]
-fn test_send_compose_empty_message() {
+fn test_send_compose_allows_empty_message() {
     let context = setup();
     let env = &context.env;
     let endpoint_client = &context.endpoint_client;
@@ -153,21 +108,35 @@ fn test_send_compose_empty_message() {
     let index = 0u32;
     let message = Bytes::new(env);
 
-    // Mock auth for 'from' address
-    env.mock_auths(&[MockAuth {
-        address: &from,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint_client.address,
-            fn_name: "send_compose",
-            args: (&from, &to, &guid, &index, &message).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
+    context.send_compose_with_auth(&from, &to, &guid, index, &message);
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &index), Some(keccak256(env, &message)));
+}
 
-    endpoint_client.send_compose(&from, &to, &guid, &index, &message);
+// The compose_queue keying (from/to/guid/index) and uniqueness
+#[test]
+fn test_send_compose_keying_and_compose_exists() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let from = Address::generate(env);
+    let to = Address::generate(env);
+    let guid = BytesN::from_array(env, &[1u8; 32]);
+    let message1 = Bytes::from_array(env, &[1, 2, 3]);
+    let message2 = Bytes::from_array(env, &[4, 5, 6]);
+
+    // Baseline: store one compose entry.
+    context.send_compose_with_auth(&from, &to, &guid, 0, &message1);
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &0), Some(keccak256(env, &message1)));
+
+    // Different index should be independent.
+    context.send_compose_with_auth(&from, &to, &guid, 1, &message2);
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &1), Some(keccak256(env, &message2)));
+
+    // Same (from,to,guid,index) => ComposeExists.
+    let result = try_send_compose_with_auth(&context, &from, &to, &guid, 0, &message2);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::ComposeExists.into());
 
-    // Verify the compose queue was set with empty message hash
-    let message_hash = keccak256(env, &message);
-    let stored_hash = endpoint_client.compose_queue(&from, &to, &guid, &index);
-    assert_eq!(stored_hash, Some(message_hash));
+    // Ensure ComposeExists did not overwrite the originally stored entry.
+    assert_eq!(endpoint_client.compose_queue(&from, &to, &guid, &0), Some(keccak256(env, &message1)));
 }

package/contracts/endpoint-v2/src/tests/mock.rs

@@ -1,10 +1,10 @@
-use crate::{interfaces::MessagingFee, FeeRecipient, FeesAndPacket, MessageLibType, Origin, OutboundPacket};
 use soroban_sdk::{contract, contractimpl, vec, Address, Bytes, Env, Symbol, Vec};
 
-// ============================================================================
-// Mock Receiver Contract for Testing
-// ============================================================================
+use crate::{
+    interfaces::MessagingFee, FeeRecipient, FeesAndPacket, MessageLibType, Origin, OutboundPacket, SetConfigParam,
+};
 
+// Mock Receiver Contract for Testing
 #[contract]
 pub struct MockReceiver;
 
@@ -57,6 +57,20 @@ impl MockMessageLib {
             env.storage().instance().get(&Symbol::new(&env, "supported_eids")).unwrap_or(vec![&env]);
         supported_eids.contains(eid)
     }
+
+    /// Stores config for an OApp. This is a minimal implementation to support endpoint tests.
+    pub fn set_config(env: Env, oapp: Address, params: Vec<SetConfigParam>) {
+        let prefix = Symbol::new(&env, "cfg");
+        for p in params.iter() {
+            env.storage().instance().set(&(prefix.clone(), oapp.clone(), p.eid, p.config_type), &p.config);
+        }
+    }
+
+    /// Reads config for an OApp. Returns empty bytes if unset.
+    pub fn get_config(env: Env, eid: u32, oapp: Address, config_type: u32) -> Bytes {
+        let prefix = Symbol::new(&env, "cfg");
+        env.storage().instance().get(&(prefix, oapp, eid, config_type)).unwrap_or(Bytes::new(&env))
+    }
 }
 
 // Mock send library for testing send/quote operations

package/contracts/endpoint-v2/src/tests/util/build_payload.rs

@@ -1,6 +1,7 @@
-use crate::{tests::endpoint_setup::setup, util::build_payload};
 use soroban_sdk::{Bytes, BytesN};
 
+use crate::{tests::endpoint_setup::setup, util::build_payload};
+
 #[test]
 fn test_build_payload_basic() {
     let context = setup();
@@ -20,6 +21,8 @@ fn test_build_payload() {
     let context = setup();
     let env = &context.env;
 
+    // Mirrors with sui
+
     // Create a guid with 32 periods (ASCII 46 = '.')
     let guid_bytes = [46u8; 32];
     let guid = BytesN::from_array(env, &guid_bytes);
@@ -42,7 +45,6 @@ fn test_build_payload() {
     assert_eq!(payload, expected);
 }
 
-
 #[test]
 fn test_build_payload_empty_message() {
     let context = setup();
@@ -56,71 +58,3 @@ fn test_build_payload_empty_message() {
     // Payload should be just the 32 bytes of GUID
     assert_eq!(payload.len(), 32);
 }
-
-#[test]
-fn test_build_payload_large_message() {
-    let context = setup();
-    let env = &context.env;
-
-    let guid = BytesN::from_array(env, &[1u8; 32]);
-    let message = Bytes::from_array(env, &[255u8; 1000]);
-
-    let payload = build_payload(env, &guid, &message);
-
-    // Payload should be 32 bytes (guid) + 1000 bytes (message)
-    assert_eq!(payload.len(), 32 + 1000);
-}
-
-
-#[test]
-fn test_build_payload_all_zero_guid() {
-    let context = setup();
-    let env = &context.env;
-
-    let guid = BytesN::from_array(env, &[0u8; 32]);
-    let message = Bytes::from_array(env, &[1, 2, 3]);
-
-    let payload = build_payload(env, &guid, &message);
-
-    // Should successfully build payload with all-zero GUID
-    assert_eq!(payload.len(), 32 + 3);
-
-    // First 32 bytes should be zeros
-    for i in 0..32 {
-        assert_eq!(payload.get(i).unwrap(), 0u8);
-    }
-}
-
-
-#[test]
-fn test_build_payload_single_byte_message() {
-    let context = setup();
-    let env = &context.env;
-
-    let guid = BytesN::from_array(env, &[1u8; 32]);
-    let message = Bytes::from_array(env, &[42]);
-
-    let payload = build_payload(env, &guid, &message);
-
-    // Payload should be 32 bytes (guid) + 1 byte (message)
-    assert_eq!(payload.len(), 33);
-    assert_eq!(payload.get(32).unwrap(), 42u8);
-}
-
-
-#[test]
-fn test_build_payload_preserves_message_order() {
-    let context = setup();
-    let env = &context.env;
-
-    let guid = BytesN::from_array(env, &[0u8; 32]);
-    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-
-    let payload = build_payload(env, &guid, &message);
-
-    // Verify message bytes are preserved in order after GUID
-    for i in 0..10 {
-        assert_eq!(payload.get(32 + i).unwrap(), (i + 1) as u8);
-    }
-}
-

package/contracts/endpoint-v2/src/tests/util/compute_guid.rs

@@ -1,7 +1,8 @@
-use crate::{tests::endpoint_setup::setup, util::compute_guid};
 use hex_literal::hex;
 use soroban_sdk::{address_payload::AddressPayload, testutils::Address as _, Address, BytesN, Env};
 
+use crate::{tests::endpoint_setup::setup, util::compute_guid};
+
 #[test]
 fn test_compute_guid_basic() {
     let context = setup();

package/contracts/endpoint-v2/src/tests/util/keccak256.rs

@@ -1,115 +1,26 @@
-use crate::{tests::endpoint_setup::setup, util::keccak256};
-use soroban_sdk::Bytes;
-
-#[test]
-fn test_keccak256_basic() {
-    let context = setup();
-    let env = &context.env;
-
-    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
-
-    let hash = keccak256(env, &message);
-
-    // Hash should be 32 bytes
-    assert_eq!(hash.len(), 32);
-}
-
-#[test]
-fn test_keccak256_empty_message() {
-    let context = setup();
-    let env = &context.env;
-
-    let message = Bytes::new(env);
-
-    let hash = keccak256(env, &message);
-
-    // Hash of empty message should still be 32 bytes
-    assert_eq!(hash.len(), 32);
-}
-
-#[test]
-fn test_keccak256_deterministic() {
-    let context = setup();
-    let env = &context.env;
-
-    let message = Bytes::from_array(env, &[1, 2, 3, 4, 5]);
-
-    // Hash the same message twice
-    let hash1 = keccak256(env, &message);
-    let hash2 = keccak256(env, &message);
-
-    // Should produce the same hash
-    assert_eq!(hash1, hash2);
-}
-
-#[test]
-fn test_keccak256_different_messages() {
-    let context = setup();
-    let env = &context.env;
+use hex_literal::hex;
+use soroban_sdk::{Bytes, BytesN};
 
-    let message1 = Bytes::from_array(env, &[1, 2, 3]);
-    let message2 = Bytes::from_array(env, &[4, 5, 6]);
-
-    let hash1 = keccak256(env, &message1);
-    let hash2 = keccak256(env, &message2);
-
-    // Different messages should produce different hashes
-    assert_ne!(hash1, hash2);
-}
-
-#[test]
-fn test_keccak256_single_byte() {
-    let context = setup();
-    let env = &context.env;
-
-    let message = Bytes::from_array(env, &[42]);
-
-    let hash = keccak256(env, &message);
-
-    // Hash should be 32 bytes
-    assert_eq!(hash.len(), 32);
-}
-
-#[test]
-fn test_keccak256_large_message() {
-    let context = setup();
-    let env = &context.env;
-
-    let message = Bytes::from_array(env, &[255u8; 1000]);
-
-    let hash = keccak256(env, &message);
-
-    // Hash should still be 32 bytes
-    assert_eq!(hash.len(), 32);
-}
-
-#[test]
-fn test_keccak256_all_zeros() {
-    let context = setup();
-    let env = &context.env;
-
-    let message = Bytes::from_array(env, &[0u8; 100]);
-
-    let hash = keccak256(env, &message);
-
-    // Hash should be 32 bytes
-    assert_eq!(hash.len(), 32);
-}
+use crate::{tests::endpoint_setup::setup, util::keccak256};
 
 #[test]
-fn test_keccak256_very_long_message() {
+fn test_keccak256() {
     let context = setup();
     let env = &context.env;
 
-    // Create a very long message (e.g., 10000 bytes)
-    let mut data = [0u8; 10000];
-    for i in 0..10000 {
-        data[i] = (i % 256) as u8;
-    }
-    let message = Bytes::from_array(env, &data);
+    // Mirrors with sui
 
-    let hash = keccak256(env, &message);
+    // keccak256("")
+    let empty = Bytes::new(env);
+    let empty_hash = keccak256(env, &empty);
+    let expected_empty =
+        BytesN::from_array(env, &hex!("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"));
+    assert_eq!(empty_hash, expected_empty);
 
-    // Hash should still be 32 bytes regardless of input size
-    assert_eq!(hash.len(), 32);
+    // keccak256("hello world")
+    let message = Bytes::from_slice(env, b"hello world");
+    let message_hash = keccak256(env, &message);
+    let expected_message =
+        BytesN::from_array(env, &hex!("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad"));
+    assert_eq!(message_hash, expected_message);
 }

package/contracts/layerzero-views/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "layerzero-views"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+doctest = false
+
+[features]
+library = []
+testutils = []
+# Network selection
+mainnet = []
+testnet = []
+sandbox = []
+
+[dependencies]
+cfg-if = { workspace = true }
+soroban-sdk = { workspace = true }
+# workspace dependencies
+utils = { workspace = true }
+common-macros = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+message-lib-common = { workspace = true }
+uln302 = { workspace = true, features = ["library"] }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+endpoint-v2 = { workspace = true, features = ["testutils"] }
+message-lib-common = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }
+uln302 = { workspace = true, features = ["testutils"] }

package/contracts/layerzero-views/src/errors.rs

@@ -0,0 +1,10 @@
+//! Error types for LayerZero view contracts.
+
+use common_macros::contract_error;
+
+/// Errors for LayerZeroView contract.
+#[contract_error]
+pub enum LayerZeroViewError {
+    /// Invalid packet header (dst_eid mismatch).
+    InvalidEID,
+}