@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

package/contracts/layerzero-views/src/tests/setup.rs

@@ -0,0 +1,377 @@
+//! Test setup and mock contracts for LayerZero view tests.
+
+use common_macros::contract_impl;
+use endpoint_v2::{MessageLibClient, Origin, OutboundPacket, SetConfigParam};
+use message_lib_common::packet_codec_v1;
+use soroban_sdk::{
+    address_payload::AddressPayload, contract, log, testutils::Address as _, Address, Bytes, BytesN, Env, Vec,
+};
+
+use crate::{LayerZeroView, LayerZeroViewClient};
+
+pub const LOCAL_EID: u32 = 30010;
+pub const REMOTE_EID: u32 = 30011;
+
+// ============================================================================
+// Mock Endpoint Contract
+// ============================================================================
+
+/// Mock endpoint that provides basic endpoint functionality for testing.
+/// Uses simple setters to control return values - real endpoint logic is tested separately.
+#[contract]
+pub struct MockEndpoint;
+
+mod endpoint_storage {
+    use soroban_sdk::{contracttype, Address, BytesN};
+
+    #[contracttype]
+    pub enum MockEndpointStorage {
+        // Simple return value controls
+        Initializable(Address, u32, BytesN<32>),
+        Verifiable(Address, u32, BytesN<32>),
+        // State for executable tests
+        LazyInboundNonce(Address, u32, BytesN<32>),
+        InboundNonce(Address, u32, BytesN<32>),
+        InboundPayloadHash(Address, u32, BytesN<32>, u64),
+        ReceiveLibrary(Address, u32),
+    }
+}
+
+#[contract_impl]
+impl MockEndpoint {
+    pub fn eid(_env: &Env) -> u32 {
+        LOCAL_EID
+    }
+
+    pub fn set_config(env: &Env, _caller: &Address, oapp: &Address, lib: &Address, params: &Vec<SetConfigParam>) {
+        let msglib = MessageLibClient::new(env, lib);
+        msglib.set_config(oapp, params);
+    }
+
+    /// Returns initializable state - controlled by set_initializable setter.
+    pub fn initializable(env: &Env, origin: &Origin, receiver: &Address) -> bool {
+        env.storage()
+            .persistent()
+            .get(&endpoint_storage::MockEndpointStorage::Initializable(
+                receiver.clone(),
+                origin.src_eid,
+                origin.sender.clone(),
+            ))
+            .unwrap_or(false)
+    }
+
+    /// Returns verifiable state - controlled by set_verifiable setter.
+    pub fn verifiable(env: &Env, origin: &Origin, receiver: &Address) -> bool {
+        env.storage()
+            .persistent()
+            .get(&endpoint_storage::MockEndpointStorage::Verifiable(
+                receiver.clone(),
+                origin.src_eid,
+                origin.sender.clone(),
+            ))
+            .unwrap_or(true) // Default true so tests can focus on other conditions
+    }
+
+    // =========================================================================
+    // Setters for controlling mock behavior
+    // =========================================================================
+
+    /// Set what initializable() returns for a given path.
+    pub fn set_initializable(env: &Env, receiver: &Address, src_eid: &u32, sender: &BytesN<32>, value: &bool) {
+        env.storage().persistent().set(
+            &endpoint_storage::MockEndpointStorage::Initializable(receiver.clone(), *src_eid, sender.clone()),
+            value,
+        );
+    }
+
+    /// Set what verifiable() returns for a given path.
+    pub fn set_verifiable(env: &Env, receiver: &Address, src_eid: &u32, sender: &BytesN<32>, value: &bool) {
+        env.storage()
+            .persistent()
+            .set(&endpoint_storage::MockEndpointStorage::Verifiable(receiver.clone(), *src_eid, sender.clone()), value);
+    }
+
+    pub fn set_lazy_inbound_nonce(env: &Env, receiver: &Address, src_eid: &u32, sender: &BytesN<32>, nonce: &u64) {
+        env.storage().persistent().set(
+            &endpoint_storage::MockEndpointStorage::LazyInboundNonce(receiver.clone(), *src_eid, sender.clone()),
+            nonce,
+        );
+    }
+
+    pub fn set_inbound_nonce(env: &Env, receiver: &Address, src_eid: &u32, sender: &BytesN<32>, nonce: &u64) {
+        env.storage().persistent().set(
+            &endpoint_storage::MockEndpointStorage::InboundNonce(receiver.clone(), *src_eid, sender.clone()),
+            nonce,
+        );
+    }
+
+    pub fn set_inbound_payload_hash(
+        env: &Env,
+        receiver: &Address,
+        src_eid: &u32,
+        sender: &BytesN<32>,
+        nonce: &u64,
+        payload_hash: &Option<BytesN<32>>,
+    ) {
+        let key = endpoint_storage::MockEndpointStorage::InboundPayloadHash(
+            receiver.clone(),
+            *src_eid,
+            sender.clone(),
+            *nonce,
+        );
+        match payload_hash {
+            Some(hash) => env.storage().persistent().set(&key, hash),
+            None => env.storage().persistent().remove(&key),
+        }
+    }
+
+    pub fn set_receive_library(env: &Env, receiver: &Address, src_eid: &u32, lib: &Address) {
+        env.storage()
+            .persistent()
+            .set(&endpoint_storage::MockEndpointStorage::ReceiveLibrary(receiver.clone(), *src_eid), lib);
+    }
+
+    // =========================================================================
+    // Getters required by LayerZeroView
+    // =========================================================================
+
+    pub fn lazy_inbound_nonce(env: &Env, receiver: &Address, src_eid: &u32, sender: &BytesN<32>) -> u64 {
+        env.storage()
+            .persistent()
+            .get(&endpoint_storage::MockEndpointStorage::LazyInboundNonce(receiver.clone(), *src_eid, sender.clone()))
+            .unwrap_or(0)
+    }
+
+    pub fn inbound_nonce(env: &Env, receiver: &Address, src_eid: &u32, sender: &BytesN<32>) -> u64 {
+        env.storage()
+            .persistent()
+            .get(&endpoint_storage::MockEndpointStorage::InboundNonce(receiver.clone(), *src_eid, sender.clone()))
+            .unwrap_or(0)
+    }
+
+    pub fn inbound_payload_hash(
+        env: &Env,
+        receiver: &Address,
+        src_eid: &u32,
+        sender: &BytesN<32>,
+        nonce: &u64,
+    ) -> Option<BytesN<32>> {
+        env.storage().persistent().get(&endpoint_storage::MockEndpointStorage::InboundPayloadHash(
+            receiver.clone(),
+            *src_eid,
+            sender.clone(),
+            *nonce,
+        ))
+    }
+
+    pub fn is_valid_receive_library(env: &Env, receiver: &Address, src_eid: &u32, lib: &Address) -> bool {
+        let stored_lib: Option<Address> = env
+            .storage()
+            .persistent()
+            .get(&endpoint_storage::MockEndpointStorage::ReceiveLibrary(receiver.clone(), *src_eid));
+
+        match stored_lib {
+            Some(stored) => &stored == lib,
+            None => true, // Default: any lib is valid if not set
+        }
+    }
+}
+
+// ============================================================================
+// Mock ULN302 Contract (minimal for testing)
+// ============================================================================
+
+mod uln_storage {
+    use soroban_sdk::{contracttype, BytesN};
+
+    #[contracttype]
+    pub enum MockUlnStorage {
+        Owner,
+        Endpoint,
+        Treasury,
+        // Simple return value control for verifiable()
+        Verifiable(BytesN<32>, BytesN<32>), // (header_hash, payload_hash) -> bool
+    }
+}
+
+#[contract]
+pub struct MockUln302;
+
+#[contract_impl]
+impl MockUln302 {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, treasury: &Address) {
+        env.storage().persistent().set(&uln_storage::MockUlnStorage::Owner, owner);
+        env.storage().persistent().set(&uln_storage::MockUlnStorage::Endpoint, endpoint);
+        env.storage().persistent().set(&uln_storage::MockUlnStorage::Treasury, treasury);
+    }
+
+    /// Returns verifiable state - controlled by set_verifiable setter.
+    /// Default is false (Verifying state) unless explicitly set.
+    pub fn verifiable(env: &Env, packet_header: &Bytes, payload_hash: &BytesN<32>) -> bool {
+        let header_hash = endpoint_v2::util::keccak256(env, packet_header);
+        env.storage()
+            .persistent()
+            .get(&uln_storage::MockUlnStorage::Verifiable(header_hash, payload_hash.clone()))
+            .unwrap_or(false)
+    }
+
+    /// Set what verifiable() returns for a given packet header and payload hash.
+    pub fn set_verifiable(env: &Env, packet_header: &Bytes, payload_hash: &BytesN<32>, value: &bool) {
+        let header_hash = endpoint_v2::util::keccak256(env, packet_header);
+        env.storage()
+            .persistent()
+            .set(&uln_storage::MockUlnStorage::Verifiable(header_hash, payload_hash.clone()), value);
+    }
+}
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+pub struct TestSetup<'a> {
+    pub env: Env,
+    pub _owner: Address,
+    pub endpoint: Address,
+    pub endpoint_client: MockEndpointClient<'a>,
+    pub uln302: Address,
+    pub uln302_client: MockUln302Client<'a>,
+    pub view_client: LayerZeroViewClient<'a>,
+}
+
+/// Creates a full test setup with endpoint, ULN302, and view contract.
+pub fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+
+    // Deploy mock endpoint
+    let endpoint = env.register(MockEndpoint, ());
+    let endpoint_client = MockEndpointClient::new(&env, &endpoint);
+
+    // Deploy Mock ULN302 (treasury not needed for simplified mock)
+    let treasury = Address::generate(&env);
+    let uln302 = env.register(MockUln302, (&owner, &endpoint, &treasury));
+    let uln302_client = MockUln302Client::new(&env, &uln302);
+
+    // Deploy LayerZeroView
+    let view = env.register(LayerZeroView, (&owner, &endpoint, &uln302));
+    let view_client = LayerZeroViewClient::new(&env, &view);
+
+    log!(&env, "owner: {}", owner);
+    log!(&env, "endpoint: {}", endpoint);
+    log!(&env, "uln302: {}", uln302);
+    log!(&env, "view: {}", view);
+
+    TestSetup { env, _owner: owner, endpoint, endpoint_client, uln302, uln302_client, view_client }
+}
+
+impl<'a> TestSetup<'a> {
+    /// Register a mock OApp address.
+    pub fn register_oapp(&self) -> Address {
+        Address::generate(&self.env)
+    }
+
+    /// Set initializable return value for a path (endpoint mock).
+    pub fn set_initializable(&self, receiver: &Address, src_eid: u32, sender: &Address, value: bool) {
+        let sender_bytes32 = address_to_bytes32(sender);
+        self.endpoint_client.set_initializable(receiver, &src_eid, &sender_bytes32, &value);
+    }
+
+    /// Set verifiable return value for a path (endpoint mock).
+    pub fn set_verifiable(&self, receiver: &Address, src_eid: u32, sender: &Address, value: bool) {
+        let sender_bytes32 = address_to_bytes32(sender);
+        self.endpoint_client.set_verifiable(receiver, &src_eid, &sender_bytes32, &value);
+    }
+
+    /// Set lazy inbound nonce (marks messages up to this nonce as processed).
+    pub fn set_lazy_inbound_nonce(&self, receiver: &Address, src_eid: u32, sender: &Address, nonce: u64) {
+        let sender_bytes32 = address_to_bytes32(sender);
+        self.endpoint_client.set_lazy_inbound_nonce(receiver, &src_eid, &sender_bytes32, &nonce);
+    }
+
+    /// Set inbound nonce (marks messages up to this nonce as verified and executable).
+    pub fn set_inbound_nonce(&self, receiver: &Address, src_eid: u32, sender: &Address, nonce: u64) {
+        let sender_bytes32 = address_to_bytes32(sender);
+        self.endpoint_client.set_inbound_nonce(receiver, &src_eid, &sender_bytes32, &nonce);
+    }
+
+    /// Set payload hash for a specific message.
+    pub fn set_payload_hash(
+        &self,
+        receiver: &Address,
+        src_eid: u32,
+        sender: &Address,
+        nonce: u64,
+        payload_hash: &Option<BytesN<32>>,
+    ) {
+        let sender_bytes32 = address_to_bytes32(sender);
+        self.endpoint_client.set_inbound_payload_hash(receiver, &src_eid, &sender_bytes32, &nonce, payload_hash);
+    }
+
+    /// Set receive library for a receiver/src_eid combination.
+    pub fn set_receive_library(&self, receiver: &Address, src_eid: u32, lib: &Address) {
+        self.endpoint_client.set_receive_library(receiver, &src_eid, lib);
+    }
+
+    /// Set ULN302 verifiable return value for a packet header and payload hash.
+    pub fn set_uln_verifiable(&self, packet_header: &Bytes, payload_hash: &BytesN<32>, value: bool) {
+        self.uln302_client.set_verifiable(packet_header, payload_hash, &value);
+    }
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/// Extract BytesN<32> from an Address.
+pub fn address_to_bytes32(address: &Address) -> BytesN<32> {
+    match address.to_payload().unwrap() {
+        AddressPayload::AccountIdPublicKeyEd25519(payload) => payload,
+        AddressPayload::ContractIdHash(payload) => payload,
+    }
+}
+
+/// Create a test packet header.
+pub fn create_test_packet_header(env: &Env, receiver: &Address, sender: &Address, nonce: u64) -> Bytes {
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let message = Bytes::from_array(env, &[0x01, 0x02, 0x03, 0x04]);
+
+    let packet = OutboundPacket {
+        nonce,
+        src_eid: REMOTE_EID,
+        sender: sender.clone(),
+        dst_eid: LOCAL_EID,
+        receiver: address_to_bytes32(receiver),
+        guid,
+        message,
+    };
+    packet_codec_v1::encode_packet_header(env, &packet)
+}
+
+/// Create a test packet header with custom dst_eid.
+pub fn create_test_packet_header_with_eid(
+    env: &Env,
+    receiver: &Address,
+    sender: &Address,
+    nonce: u64,
+    dst_eid: u32,
+) -> Bytes {
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let message = Bytes::from_array(env, &[0x01, 0x02, 0x03, 0x04]);
+
+    let packet = OutboundPacket {
+        nonce,
+        src_eid: REMOTE_EID,
+        sender: sender.clone(),
+        dst_eid,
+        receiver: address_to_bytes32(receiver),
+        guid,
+        message,
+    };
+    packet_codec_v1::encode_packet_header(env, &packet)
+}
+
+/// Create a test payload hash.
+pub fn create_test_payload_hash(env: &Env) -> BytesN<32> {
+    let random_data = Bytes::from_array(env, &[0xde, 0xad, 0xbe, 0xef]);
+    endpoint_v2::util::keccak256(env, &random_data)
+}

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

@@ -0,0 +1,50 @@
+//! Shared types for LayerZero view contracts.
+
+use endpoint_v2::constants::{EMPTY_PAYLOAD_HASH_BYTES, NIL_PAYLOAD_HASH_BYTES};
+use soroban_sdk::{contracttype, BytesN, Env};
+
+/// Represents the execution state of a cross-chain message.
+///
+/// Used by executors to determine when a message is ready to be delivered.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ExecutionState {
+    /// Message is not ready for execution - waiting for verification.
+    NotExecutable,
+    /// Message is verified but cannot be executed yet (prior nonces pending).
+    VerifiedButNotExecutable,
+    /// Message is ready to be executed.
+    Executable,
+    /// Message has already been executed.
+    Executed,
+}
+
+/// Represents the verification state of a cross-chain message at the ULN level.
+///
+/// Used by DVNs and executors to track verification progress.
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum VerificationState {
+    /// DVNs are still collecting signatures/confirmations.
+    Verifying,
+    /// Has enough DVN confirmations, ready to be committed to endpoint.
+    Verifiable,
+    /// Already verified at the endpoint.
+    Verified,
+    /// Cannot be initialized (path blocked).
+    NotInitializable,
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/// Returns the empty payload hash as BytesN<32>.
+pub fn empty_payload_hash(env: &Env) -> BytesN<32> {
+    BytesN::from_array(env, &EMPTY_PAYLOAD_HASH_BYTES)
+}
+
+/// Returns the nil payload hash as BytesN<32>.
+pub fn nil_payload_hash(env: &Env) -> BytesN<32> {
+    BytesN::from_array(env, &NIL_PAYLOAD_HASH_BYTES)
+}

package/contracts/macro-integration-tests/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "macro-integration-tests"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+# This crate is primarily for testing macros.
+# The lib.rs provides shared testing utilities.
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+
+# Macro crates to be tested
+common-macros = { workspace = true }
+oapp-macros = { workspace = true }
+# oft-macros = { workspace = true }  # TODO: Add when available
+
+# Runtime libraries (for verifying generated code behavior)
+utils = { workspace = true }
+oapp = { workspace = true }
+# oft = { workspace = true }  # TODO: Add when available
+endpoint-v2 = { workspace = true, features = ["library"] }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }
+trybuild = "1.0.114"

package/contracts/macro-integration-tests/src/lib.rs

@@ -0,0 +1 @@
+

package/contracts/macro-integration-tests/tests/runtime/ownable/initialization.rs

@@ -0,0 +1,62 @@
+// Runtime tests: Owner initialization behavior.
+//
+// Tests covered:
+// - `init_owner` + `owner()` query works correctly.
+// - Double initialization is rejected.
+// - Uninitialized owner returns None and operations fail.
+
+use super::{TestContract, TestContractClient};
+use soroban_sdk::{testutils::Address as _, Address, Env};
+use utils::errors::OwnableError;
+
+#[test]
+fn init_and_query() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    client.init(&owner);
+
+    let got = client.owner();
+    assert_eq!(got, Some(owner));
+}
+
+#[test]
+fn double_init_fails() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner_a = Address::generate(&env);
+    let owner_b = Address::generate(&env);
+
+    // First initialization should succeed
+    client.init(&owner_a);
+    assert_eq!(client.owner(), Some(owner_a.clone()));
+
+    // Second initialization should fail
+    let result = client.try_init(&owner_b);
+    assert_eq!(result.unwrap_err().unwrap(), OwnableError::OwnerAlreadySet.into());
+
+    // Original owner should remain unchanged
+    assert_eq!(client.owner(), Some(owner_a));
+}
+
+#[test]
+fn uninitialized_returns_none() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    // No init() call - owner should be None
+    assert_eq!(client.owner(), None);
+
+    // All owner-protected operations should fail
+    assert_eq!(client.try_guarded().unwrap_err().unwrap(), OwnableError::OwnerNotSet.into());
+    assert_eq!(
+        client.try_transfer_ownership(&Address::generate(&env)).unwrap_err().unwrap(),
+        OwnableError::OwnerNotSet.into()
+    );
+    assert_eq!(client.try_renounce_ownership().unwrap_err().unwrap(), OwnableError::OwnerNotSet.into());
+}

package/contracts/macro-integration-tests/tests/runtime/ownable/mod.rs

@@ -0,0 +1,22 @@
+use soroban_sdk::{contract, contractimpl, Address, Env};
+
+mod initialization;
+mod only_owner_guard;
+mod ownership_transfer;
+
+/// Shared contract used by ownable runtime tests.
+#[contract]
+#[common_macros::ownable]
+pub struct TestContract;
+
+#[contractimpl]
+impl TestContract {
+    pub fn init(env: Env, owner: Address) {
+        Self::init_owner(&env, &owner);
+    }
+
+    #[common_macros::only_owner]
+    pub fn guarded(env: &Env) {
+        let _ = env;
+    }
+}

package/contracts/macro-integration-tests/tests/runtime/ownable/only_owner_guard.rs

@@ -0,0 +1,97 @@
+// Runtime tests: `#[only_owner]` guard behavior.
+//
+// Tests covered:
+// - Guard enforces owner authorization (unauthorized fails, authorized succeeds).
+// - Guard respects ownership transfer (old owner rejected, new owner accepted).
+
+use super::{TestContract, TestContractClient};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    xdr::{ScErrorCode, ScErrorType},
+    Address, Env, Error, IntoVal,
+};
+
+#[test]
+fn guard_enforces_auth() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner = Address::generate(&env);
+    client.init(&owner);
+
+    // Unauthorized call should fail
+    let unauthorized = client.try_guarded();
+    assert_eq!(
+        unauthorized.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // Authorized call should succeed
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "guarded",
+                args: ().into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .guarded();
+}
+
+#[test]
+fn guard_respects_transfer() {
+    let env = Env::default();
+    let contract_id = env.register(TestContract, ());
+    let client = TestContractClient::new(&env, &contract_id);
+
+    let owner_a = Address::generate(&env);
+    let owner_b = Address::generate(&env);
+
+    client.init(&owner_a);
+
+    // Transfer ownership A -> B
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner_a,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "transfer_ownership",
+                args: (&owner_b,).into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .transfer_ownership(&owner_b);
+
+    // Old owner (A) should be rejected even with auth
+    let a_call = client
+        .mock_auths(&[MockAuth {
+            address: &owner_a,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "guarded",
+                args: ().into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .try_guarded();
+    assert_eq!(
+        a_call.unwrap_err().unwrap(),
+        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
+    );
+
+    // New owner (B) should be accepted with auth
+    client
+        .mock_auths(&[MockAuth {
+            address: &owner_b,
+            invoke: &MockAuthInvoke {
+                contract: &contract_id,
+                fn_name: "guarded",
+                args: ().into_val(&env),
+                sub_invokes: &[],
+            },
+        }])
+        .guarded();
+}