@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,76 @@
+#[contractimpl]
+impl IMessagingComposer for EndpointV2 {
+    /// Sends a composed message from an OApp to a composer.
+    ///
+    /// The composer MUST assert the sender because anyone can send compose msg with this function.
+    /// With the same GUID, the OApp can send compose to multiple composers at the same time.
+    fn send_compose(env: &Env, from: &Address, to: &Address, guid: &BytesN<32>, index: u32, message: &Bytes) {
+        from.require_auth();
+        assert_with_error!(env, index <= MAX_COMPOSE_INDEX, EndpointError::InvalidIndex);
+
+        let compose_queue = Self::compose_queue(env, from, to, guid, index);
+        assert_with_error!(env, compose_queue.is_none(), EndpointError::ComposeExists);
+
+        let message_hash = keccak256(env, message);
+        EndpointStorage::set_compose_queue(env, from, to, guid, index, &message_hash);
+        ComposeSent { from: from.clone(), to: to.clone(), guid: guid.clone(), index, message: message.clone() }
+            .publish(env);
+    }
+
+    /// Clears a composed message by the composer.
+    ///
+    /// This is a PULL mode versus the PUSH mode of `lz_compose`.
+    fn clear_compose(env: &Env, composer: &Address, from: &Address, guid: &BytesN<32>, index: u32, message: &Bytes) {
+        composer.require_auth();
+        assert_with_error!(env, index <= MAX_COMPOSE_INDEX, EndpointError::InvalidIndex);
+
+        let expected_hash = Self::compose_queue(env, from, composer, guid, index);
+        let actual_hash = keccak256(env, message);
+        assert_with_error!(env, expected_hash == Some(actual_hash), EndpointError::ComposeNotFound);
+
+        let received_hash = BytesN::from_array(env, &RECEIVED_MESSAGE_HASH_BYTES);
+        EndpointStorage::set_compose_queue(env, from, composer, guid, index, &received_hash);
+
+        ComposeDelivered { from: from.clone(), to: composer.clone(), guid: guid.clone(), index }.publish(env);
+    }
+
+    /// Emits an alert event when `lz_compose` execution fails.
+    ///
+    /// Called by the executor to notify about failed compose message delivery attempts.
+    fn lz_compose_alert(
+        env: &Env,
+        executor: &Address,
+        from: &Address,
+        to: &Address,
+        guid: &BytesN<32>,
+        index: u32,
+        gas: i128,
+        value: i128,
+        message: &Bytes,
+        extra_data: &Bytes,
+        reason: &Bytes,
+    ) {
+        executor.require_auth();
+        assert_with_error!(env, index <= MAX_COMPOSE_INDEX, EndpointError::InvalidIndex);
+        LzComposeAlert {
+            executor: executor.clone(),
+            from: from.clone(),
+            to: to.clone(),
+            guid: guid.clone(),
+            index,
+            gas,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        }
+        .publish(env);
+    }
+
+    // === View Functions ===
+
+    /// Returns the stored hash for a composed message, or `None` if not queued.
+    fn compose_queue(env: &Env, from: &Address, to: &Address, guid: &BytesN<32>, index: u32) -> Option<BytesN<32>> {
+        EndpointStorage::compose_queue(env, from, to, guid, index)
+    }
+}

package/contracts/endpoint-v2/src/storage.rs

@@ -0,0 +1,78 @@
+use crate::Timeout;
+use common_macros::storage;
+use soroban_sdk::{Address, BytesN};
+use utils::ttl::DefaultTtlConfigProvider;
+
+#[storage(DefaultTtlConfigProvider)]
+pub enum EndpointStorage {
+    /// The ZRO token address
+    #[instance(Address)]
+    ZRO,
+
+    /// The delegate address for an OApp
+    #[persistent(Address)]
+    Delegate { oapp: Address },
+
+    /// === Messaging Channel ===
+
+    /// The lazy inbound nonce for a receiver
+    #[persistent(u64)]
+    #[default(0)]
+    LazyInboundNonce { receiver: Address, src_eid: u32, sender: BytesN<32> },
+
+    /// The inbound payload hash for a receiver
+    #[persistent(BytesN<32>)]
+    #[no_auto_ttl_extension]
+    InboundPayloadHash { receiver: Address, src_eid: u32, sender: BytesN<32>, nonce: u64 },
+
+    /// The outbound nonce for a sender
+    #[persistent(u64)]
+    #[default(0)]
+    OutboundNonce { sender: Address, dst_eid: u32, receiver: BytesN<32> },
+
+    /// === Message Lib Manager ===
+
+    /// The number of registered libraries
+    #[instance(u32)]
+    #[default(0)]
+    RegisteredLibraryCount,
+
+    /// The mapping of library to index
+    #[persistent(u32)]
+    LibraryToIndex { lib: Address },
+
+    /// The mapping of index to library
+    #[persistent(Address)]
+    IndexToLibrary { index: u32 },
+
+    /// The default send library for a destination endpoint
+    #[persistent(Address)]
+    DefaultSendLibrary { dst_eid: u32 },
+
+    /// The default receive library for a source endpoint
+    #[persistent(Address)]
+    DefaultReceiveLibrary { src_eid: u32 },
+
+    /// The default receive library grace period for a source endpoint
+    #[persistent(Timeout)]
+    DefaultReceiveLibraryTimeout { src_eid: u32 },
+
+    /// The custom send library for a sender and destination endpoint
+    #[persistent(Address)]
+    SendLibrary { sender: Address, dst_eid: u32 },
+
+    /// The custom receive library for a receiver and source endpoint
+    #[persistent(Address)]
+    ReceiveLibrary { receiver: Address, src_eid: u32 },
+
+    /// The custom receive library grace period for a receiver and source endpoint
+    #[persistent(Timeout)]
+    ReceiveLibraryTimeout { receiver: Address, src_eid: u32 },
+
+    /// === Messaging Composer ===
+
+    /// The compose queue for a sender and receiver
+    #[persistent(BytesN<32>)]
+    #[no_auto_ttl_extension]
+    ComposeQueue { from: Address, to: Address, guid: BytesN<32>, index: u32 },
+}

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

@@ -0,0 +1,131 @@
+use crate::{
+    endpoint_v2::{EndpointV2, EndpointV2Client},
+    tests::mock::{
+        MockMessageLib, MockMessageLibClient, MockReceiveLib, MockReceiveLibClient, MockSendLib, MockSendLibClient,
+    },
+    MessageLibType,
+};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    token::StellarAssetClient,
+    Address, Env, IntoVal, Val, Vec,
+};
+
+pub struct TestSetup<'a> {
+    pub eid: u32,
+    pub endpoint_client: EndpointV2Client<'a>,
+    pub env: Env,
+    pub owner: Address,
+    pub contract_id: Address,
+    pub native_token_client: StellarAssetClient<'a>,
+    pub zro_token_client: StellarAssetClient<'a>,
+}
+
+pub fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+
+    let owner = Address::generate(&env);
+
+    // Deploy native token contract
+    let native_token = env.register_stellar_asset_contract_v2(owner.clone());
+    let native_token_address = native_token.address();
+    let native_token_client = StellarAssetClient::new(&env, &native_token_address);
+
+    // Deploy ZRO token
+    let zro_token = env.register_stellar_asset_contract_v2(owner.clone());
+    let zro_token_address = zro_token.address();
+    let zro_token_client = StellarAssetClient::new(&env, &zro_token_address);
+
+    // Deploy the endpoint contract
+    let contract_id = env.register(EndpointV2, (&owner,));
+    let client = EndpointV2Client::new(&env, &contract_id);
+    let eid = client.eid();
+
+    TestSetup { eid, endpoint_client: client, env, owner, contract_id, native_token_client, zro_token_client }
+}
+
+impl<'a> TestSetup<'a> {
+    /// Helper function to mint native tokens with proper authorization
+    pub fn mint_native(&self, to: &Address, amount: i128) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.native_token_client.address,
+                fn_name: "mint",
+                args: (to, amount).into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.native_token_client.mint(to, &amount);
+    }
+
+    /// Helper function to mint ZRO tokens with proper authorization
+    pub fn mint_zro(&self, to: &Address, amount: i128) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.zro_token_client.address,
+                fn_name: "mint",
+                args: (to, amount).into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        self.zro_token_client.mint(to, &amount);
+    }
+
+    // Helper to mock owner auth for common operations
+    pub fn mock_owner_auth<T: IntoVal<Env, Vec<Val>>>(&self, fn_name: &str, args: T) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.contract_id,
+                fn_name,
+                args: args.into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+    }
+
+    // Helper to mock auth for any address
+    pub fn mock_auth<T: IntoVal<Env, Vec<Val>>>(&self, address: &Address, fn_name: &str, args: T) {
+        self.env.mock_auths(&[MockAuth {
+            address,
+            invoke: &MockAuthInvoke {
+                contract: &self.contract_id,
+                fn_name,
+                args: args.into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+    }
+
+    // Helper function to create and setup a mock message library
+    pub fn setup_mock_message_lib(&self, lib_type: MessageLibType, supported_eids: Vec<u32>) -> Address {
+        let lib = self.env.register(MockMessageLib, ());
+        let lib_client = MockMessageLibClient::new(&self.env, &lib);
+        lib_client.setup(&lib_type, &supported_eids);
+        lib
+    }
+
+    // Helper function to create and setup a mock send library
+    pub fn setup_mock_send_lib(
+        &self,
+        supported_eids: Vec<u32>,
+        native_fee: i128,
+        zro_fee: i128,
+        fee_recipient: Address,
+    ) -> Address {
+        let lib = self.env.register(MockSendLib, ());
+        let lib_client = MockSendLibClient::new(&self.env, &lib);
+        lib_client.setup(&supported_eids, &native_fee, &zro_fee, &fee_recipient);
+        lib
+    }
+
+    // Helper function to create and setup a mock receive library
+    pub fn setup_mock_receive_lib(&self, supported_eids: Vec<u32>) -> Address {
+        let lib = self.env.register(MockReceiveLib, ());
+        let lib_client = MockReceiveLibClient::new(&self.env, &lib);
+        lib_client.setup(&supported_eids);
+        lib
+    }
+}

package/contracts/endpoint-v2/src/tests/endpoint_v2/clear.rs

@@ -0,0 +1,237 @@
+use crate::{
+    events::PacketDelivered,
+    storage,
+    tests::{endpoint_setup::setup, mock::MockReceiver},
+    util::{build_payload, keccak256},
+    Origin,
+};
+use soroban_sdk::{
+    testutils::{MockAuth, MockAuthInvoke},
+    vec, Bytes, BytesN, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_clear_success() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let receiver = env.register(MockReceiver, ());
+    let nonce = 1u64;
+
+    // Setup receive library
+    let receive_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+    context.mock_owner_auth("set_default_receive_library", (&src_eid, &receive_lib, &0u64));
+    endpoint_client.set_default_receive_library(&src_eid, &receive_lib, &0);
+
+    // Create message and payload
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let payload = build_payload(env, &guid, &message);
+    let payload_hash = keccak256(env, &payload);
+
+    let origin = Origin { src_eid, sender: sender.clone(), nonce };
+
+    // First verify the packet
+    env.mock_auths(&[MockAuth {
+        address: &receive_lib,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "verify",
+            args: (&receive_lib, &origin, &receiver, &payload_hash).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash);
+
+    // Verify payload hash exists before clear
+    let hash_before_clear = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(hash_before_clear, Some(payload_hash.clone()), "Payload hash should exist before clear");
+
+    // Verify initial lazy inbound nonce
+    let initial_lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
+    });
+    assert_eq!(initial_lazy_nonce, 0, "Initial lazy inbound nonce should be 0");
+
+    // Now clear the payload
+    env.mock_auths(&[MockAuth {
+        address: &receiver,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "clear",
+            args: (&receiver, &origin, &receiver, &guid, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.clear(&receiver, &origin, &receiver, &guid, &message);
+
+    // Verify PacketDelivered event was published
+    assert_event(env, &endpoint_client.address, PacketDelivered { origin: origin.clone(), receiver: receiver.clone() });
+
+    // Verify payload hash was removed via public interface
+    let stored_hash = endpoint_client.inbound_payload_hash(&receiver, &src_eid, &sender, &nonce);
+    assert_eq!(stored_hash, None);
+
+    // Assert storage change directly - payload hash removed
+    let stored_hash_direct = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::inbound_payload_hash(env, &receiver, src_eid, &sender, nonce)
+    });
+    assert_eq!(stored_hash_direct, None, "Storage should have payload hash removed");
+
+    // Verify lazy inbound nonce was updated via public interface
+    let lazy_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(lazy_nonce, nonce);
+
+    // Assert storage change directly - lazy inbound nonce updated
+    let stored_lazy_nonce = env.as_contract(&endpoint_client.address, || {
+        storage::EndpointStorage::lazy_inbound_nonce(env, &receiver, src_eid, &sender)
+    });
+    assert_eq!(stored_lazy_nonce, nonce, "Storage should contain updated lazy inbound nonce");
+}
+
+#[test]
+fn test_clear_updates_lazy_nonce() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let receiver = env.register(MockReceiver, ());
+    let nonce = 1u64;
+
+    // Setup receive library
+    let receive_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+    context.mock_owner_auth("set_default_receive_library", (&src_eid, &receive_lib, &0u64));
+    endpoint_client.set_default_receive_library(&src_eid, &receive_lib, &0);
+
+    // Create message and payload
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let payload = build_payload(env, &guid, &message);
+    let payload_hash = keccak256(env, &payload);
+
+    let origin = Origin { src_eid, sender: sender.clone(), nonce };
+
+    // First verify the packet
+    env.mock_auths(&[MockAuth {
+        address: &receive_lib,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "verify",
+            args: (&receive_lib, &origin, &receiver, &payload_hash).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.verify(&receive_lib, &origin, &receiver, &payload_hash);
+
+    // Check initial lazy nonce
+    let initial_lazy_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(initial_lazy_nonce, 0);
+
+    // Clear the payload
+    env.mock_auths(&[MockAuth {
+        address: &receiver,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "clear",
+            args: (&receiver, &origin, &receiver, &guid, &message).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.clear(&receiver, &origin, &receiver, &guid, &message);
+
+    // Verify lazy inbound nonce was updated
+    let lazy_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(lazy_nonce, nonce);
+}
+
+#[test]
+fn test_clear_sequential_nonces() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let receiver = env.register(MockReceiver, ());
+
+    // Setup receive library
+    let receive_lib = context.setup_mock_receive_lib(vec![env, src_eid]);
+    context.mock_owner_auth("register_library", (&receive_lib,));
+    endpoint_client.register_library(&receive_lib);
+    context.mock_owner_auth("set_default_receive_library", (&src_eid, &receive_lib, &0u64));
+    endpoint_client.set_default_receive_library(&src_eid, &receive_lib, &0);
+
+    // Verify and clear nonce 1
+    let message1 = Bytes::from_array(env, &[1, 2, 3]);
+    let guid1 = BytesN::from_array(env, &[1u8; 32]);
+    let payload1 = build_payload(env, &guid1, &message1);
+    let payload_hash1 = keccak256(env, &payload1);
+    let origin1 = Origin { src_eid, sender: sender.clone(), nonce: 1 };
+
+    env.mock_auths(&[MockAuth {
+        address: &receive_lib,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "verify",
+            args: (&receive_lib, &origin1, &receiver, &payload_hash1).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.verify(&receive_lib, &origin1, &receiver, &payload_hash1);
+
+    env.mock_auths(&[MockAuth {
+        address: &receiver,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "clear",
+            args: (&receiver, &origin1, &receiver, &guid1, &message1).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.clear(&receiver, &origin1, &receiver, &guid1, &message1);
+
+    // Verify and clear nonce 2
+    let message2 = Bytes::from_array(env, &[4, 5, 6]);
+    let guid2 = BytesN::from_array(env, &[2u8; 32]);
+    let payload2 = build_payload(env, &guid2, &message2);
+    let payload_hash2 = keccak256(env, &payload2);
+    let origin2 = Origin { src_eid, sender: sender.clone(), nonce: 2 };
+
+    env.mock_auths(&[MockAuth {
+        address: &receive_lib,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "verify",
+            args: (&receive_lib, &origin2, &receiver, &payload_hash2).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.verify(&receive_lib, &origin2, &receiver, &payload_hash2);
+
+    env.mock_auths(&[MockAuth {
+        address: &receiver,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "clear",
+            args: (&receiver, &origin2, &receiver, &guid2, &message2).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.clear(&receiver, &origin2, &receiver, &guid2, &message2);
+
+    // Verify lazy inbound nonce was updated to 2
+    let lazy_nonce = endpoint_client.lazy_inbound_nonce(&receiver, &src_eid, &sender);
+    assert_eq!(lazy_nonce, 2);
+}

package/contracts/endpoint-v2/src/tests/endpoint_v2/delegate.rs

@@ -0,0 +1,42 @@
+use crate::tests::endpoint_setup::setup;
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, IntoVal,
+};
+
+#[test]
+fn test_delegate_when_not_set() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+
+    let actual_delegate = endpoint_client.delegate(&oapp);
+    assert_eq!(actual_delegate, None, "Delegate should not be set");
+}
+
+#[test]
+fn test_delegate_when_set() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let delegate = Address::generate(env);
+
+    let delegate_option = Some(delegate.clone());
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_delegate",
+            args: (&oapp, &delegate_option).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_delegate(&oapp, &delegate_option);
+
+    let actual_delegate = endpoint_client.delegate(&oapp);
+    assert_eq!(actual_delegate, Some(delegate), "Delegate should be set");
+}

package/contracts/endpoint-v2/src/tests/endpoint_v2/initializable.rs

@@ -0,0 +1,76 @@
+use crate::{
+    tests::{
+        endpoint_setup::setup,
+        mock::{MockReceiver, MockReceiverReject},
+    },
+    Origin,
+};
+use soroban_sdk::BytesN;
+
+#[test]
+fn test_initializable_with_receiver_allowing_init() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    // Deploy mock receiver that allows initialization
+    let receiver = context.env.register(MockReceiver, ());
+    let src_eid = 2;
+    let sender = BytesN::from_array(&context.env, &[1u8; 32]);
+    let origin = Origin { src_eid, sender, nonce: 1 };
+
+    // For a new path (lazy nonce is 0), should depend on receiver contract
+    // MockReceiver allows initialization, so this should return true
+    let result = endpoint_client.initializable(&origin, &receiver);
+    assert!(result);
+}
+
+#[test]
+fn test_initializable_with_receiver_rejecting_init() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    // Deploy mock receiver that rejects initialization
+    let receiver = context.env.register(MockReceiverReject, ());
+    let src_eid = 2;
+    let sender = BytesN::from_array(&context.env, &[1u8; 32]);
+    let origin = Origin { src_eid, sender, nonce: 1 };
+
+    // For a new path (lazy nonce is 0), should depend on receiver contract
+    // MockReceiverReject rejects initialization, so this should return false
+    let result = endpoint_client.initializable(&origin, &receiver);
+    assert!(!result);
+}
+
+#[test]
+fn test_initializable_with_established_path() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Deploy mock receiver that rejects initialization
+    let receiver = env.register(MockReceiverReject, ());
+    let src_eid = 2;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+
+    // First establish the path by skipping nonce 1
+    let _origin = Origin { src_eid, sender: sender.clone(), nonce: 1 };
+    
+    // Set up auth for skip (receiver must authorize)
+    use soroban_sdk::{testutils::MockAuth, testutils::MockAuthInvoke, IntoVal};
+    env.mock_auths(&[MockAuth {
+        address: &receiver,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "skip",
+            args: (&receiver, &receiver, &src_eid, &sender, &1u64).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.skip(&receiver, &receiver, &src_eid, &sender, &1);
+
+    // Now the path is established (lazy_nonce > 0), should return true regardless of receiver
+    let origin2 = Origin { src_eid, sender, nonce: 2 };
+    let result = endpoint_client.initializable(&origin2, &receiver);
+    assert!(result);
+}
+