@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,513 @@
+use crate::{events::PacketSent, tests::endpoint_setup::setup, MessagingParams};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    token::TokenClient,
+    vec, Bytes, BytesN, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_send_with_native_fee_exact_payment() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = soroban_sdk::Address::generate(env);
+    let refund_address = soroban_sdk::Address::generate(env);
+    let fee_recipient = soroban_sdk::Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let options = Bytes::new(env);
+
+    // Set ZRO token (required even when not paying in ZRO due to line 79 in endpoint_v2.rs)
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Setup mock send library with 100 native fee, 0 zro fee
+    let send_lib = context.setup_mock_send_lib(vec![env, dst_eid], 100, 0, fee_recipient.clone());
+
+    // Register and set as default send library
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, &send_lib));
+    endpoint_client.set_default_send_library(&dst_eid, &send_lib);
+
+    // Mint and transfer native tokens to endpoint for payment
+    context.mint_native(&sender, 100);
+    let token_client = TokenClient::new(env, &context.native_token_client.address);
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.native_token_client.address,
+            fn_name: "transfer",
+            args: (&sender, &endpoint_client.address, &100i128).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_client.transfer(&sender, &endpoint_client.address, &100);
+
+    let params = MessagingParams {
+        dst_eid,
+        receiver: receiver.clone(),
+        message: message.clone(),
+        options: options.clone(),
+        pay_in_zro: false,
+    };
+
+    // Mock auth for sender to call send
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send",
+            args: (&sender, &params, &refund_address).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let receipt = endpoint_client.send(&sender, &params, &refund_address);
+
+    // Verify receipt
+    assert_eq!(receipt.nonce, 1);
+    assert_eq!(receipt.fee.native_fee, 100);
+    assert_eq!(receipt.fee.zro_fee, 0);
+
+    // Verify PacketSent event was published
+    // MockSendLib::send returns encoded_packet = packet.message.clone()
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketSent { encoded_packet: message, options, send_library: send_lib },
+    );
+
+    // Verify outbound nonce was incremented
+    let nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(nonce, 1);
+
+    // Verify fee was paid to fee_recipient
+    assert_eq!(context.native_token_client.balance(&fee_recipient), 100);
+
+    // Verify no refund (exact payment)
+    assert_eq!(context.native_token_client.balance(&refund_address), 0);
+}
+
+#[test]
+fn test_send_with_native_fee_and_refund() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = soroban_sdk::Address::generate(env);
+    let refund_address = soroban_sdk::Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let options = Bytes::new(env);
+    let fee_recipient = soroban_sdk::Address::generate(env);
+
+    // Set ZRO token (required even when not paying in ZRO due to line 79 in endpoint_v2.rs)
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Setup mock send library with 100 native fee
+    let send_lib = context.setup_mock_send_lib(vec![env, dst_eid], 100, 0, fee_recipient.clone());
+
+    // Register and set as default send library
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, &send_lib));
+    endpoint_client.set_default_send_library(&dst_eid, &send_lib);
+
+    // Mint and transfer MORE native tokens than needed (overpay)
+    context.mint_native(&sender, 250);
+    let token_client = TokenClient::new(env, &context.native_token_client.address);
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.native_token_client.address,
+            fn_name: "transfer",
+            args: (&sender, &endpoint_client.address, &250i128).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_client.transfer(&sender, &endpoint_client.address, &250);
+
+    let params = MessagingParams { dst_eid, receiver: receiver.clone(), message, options, pay_in_zro: false };
+
+    // Mock auth for sender to call send
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send",
+            args: (&sender, &params, &refund_address).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let receipt = endpoint_client.send(&sender, &params, &refund_address);
+
+    // Verify receipt
+    assert_eq!(receipt.nonce, 1);
+    assert_eq!(receipt.fee.native_fee, 100);
+
+    // Verify fee was paid to fee_recipient
+    assert_eq!(context.native_token_client.balance(&fee_recipient), 100);
+
+    // Verify refund (250 - 100 = 150)
+    assert_eq!(context.native_token_client.balance(&refund_address), 150);
+}
+
+#[test]
+fn test_send_increments_nonce_sequentially() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = soroban_sdk::Address::generate(env);
+    let refund_address = soroban_sdk::Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let options = Bytes::new(env);
+    let fee_recipient = soroban_sdk::Address::generate(env);
+
+    // Set ZRO token (required even when not paying in ZRO due to line 79 in endpoint_v2.rs)
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Setup mock send library
+    let send_lib = context.setup_mock_send_lib(vec![env, dst_eid], 50, 0, fee_recipient.clone());
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, &send_lib));
+    endpoint_client.set_default_send_library(&dst_eid, &send_lib);
+
+    // Mint tokens for multiple sends
+    context.mint_native(&sender, 200);
+    let token_client = TokenClient::new(env, &context.native_token_client.address);
+
+    let params = MessagingParams {
+        dst_eid,
+        receiver: receiver.clone(),
+        message: message.clone(),
+        options: options.clone(),
+        pay_in_zro: false,
+    };
+
+    // Send first message
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.native_token_client.address,
+            fn_name: "transfer",
+            args: (&sender, &endpoint_client.address, &50i128).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_client.transfer(&sender, &endpoint_client.address, &50);
+
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send",
+            args: (&sender, &params, &refund_address).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    let receipt1 = endpoint_client.send(&sender, &params, &refund_address);
+
+    // Send second message
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.native_token_client.address,
+            fn_name: "transfer",
+            args: (&sender, &endpoint_client.address, &50i128).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_client.transfer(&sender, &endpoint_client.address, &50);
+
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send",
+            args: (&sender, &params, &refund_address).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    let receipt2 = endpoint_client.send(&sender, &params, &refund_address);
+
+    // Send third message
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.native_token_client.address,
+            fn_name: "transfer",
+            args: (&sender, &endpoint_client.address, &50i128).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_client.transfer(&sender, &endpoint_client.address, &50);
+
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send",
+            args: (&sender, &params, &refund_address).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    let receipt3 = endpoint_client.send(&sender, &params, &refund_address);
+
+    // Verify nonces increment sequentially
+    assert_eq!(receipt1.nonce, 1);
+    assert_eq!(receipt2.nonce, 2);
+    assert_eq!(receipt3.nonce, 3);
+
+    // Verify final outbound nonce
+    let final_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    assert_eq!(final_nonce, 3);
+}
+
+#[test]
+fn test_send_with_custom_send_library() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = soroban_sdk::Address::generate(env);
+    let refund_address = soroban_sdk::Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let options = Bytes::new(env);
+    let default_fee_recipient = soroban_sdk::Address::generate(env);
+    let custom_fee_recipient = soroban_sdk::Address::generate(env);
+
+    // Set ZRO token (required even when not paying in ZRO due to line 79 in endpoint_v2.rs)
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Setup default send library with 100 fee
+    let default_lib = context.setup_mock_send_lib(vec![env, dst_eid], 100, 0, default_fee_recipient.clone());
+    context.mock_owner_auth("register_library", (&default_lib,));
+    endpoint_client.register_library(&default_lib);
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, &default_lib));
+    endpoint_client.set_default_send_library(&dst_eid, &default_lib);
+
+    // Setup custom send library with different fee (200)
+    let custom_lib = context.setup_mock_send_lib(vec![env, dst_eid], 200, 0, custom_fee_recipient.clone());
+    context.mock_owner_auth("register_library", (&custom_lib,));
+    endpoint_client.register_library(&custom_lib);
+
+    // Set custom library for this sender
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_send_library",
+            args: (&sender, &sender, &dst_eid, &custom_lib).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_send_library(&sender, &sender, &dst_eid, &Some(custom_lib.clone()));
+
+    // Mint and transfer tokens for custom library fee
+    context.mint_native(&sender, 200);
+    let token_client = TokenClient::new(env, &context.native_token_client.address);
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.native_token_client.address,
+            fn_name: "transfer",
+            args: (&sender, &endpoint_client.address, &200i128).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_client.transfer(&sender, &endpoint_client.address, &200);
+
+    let params = MessagingParams { dst_eid, receiver, message, options, pay_in_zro: false };
+
+    // Mock auth for sender to call send
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send",
+            args: (&sender, &params, &refund_address).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let receipt = endpoint_client.send(&sender, &params, &refund_address);
+
+    // Verify receipt uses custom library fee (200, not 100)
+    assert_eq!(receipt.fee.native_fee, 200);
+
+    // Verify fee was paid to custom_fee_recipient (not default_fee_recipient)
+    assert_eq!(context.native_token_client.balance(&custom_fee_recipient), 200);
+    assert_eq!(context.native_token_client.balance(&default_fee_recipient), 0);
+}
+
+#[test]
+fn test_send_to_different_receivers() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = soroban_sdk::Address::generate(env);
+    let refund_address = soroban_sdk::Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver1 = BytesN::from_array(env, &[1u8; 32]);
+    let receiver2 = BytesN::from_array(env, &[2u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let options = Bytes::new(env);
+    let fee_recipient = soroban_sdk::Address::generate(env);
+
+    // Set ZRO token (required even when not paying in ZRO due to line 79 in endpoint_v2.rs)
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Setup mock send library
+    let send_lib = context.setup_mock_send_lib(vec![env, dst_eid], 50, 0, fee_recipient);
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, &send_lib));
+    endpoint_client.set_default_send_library(&dst_eid, &send_lib);
+
+    // Mint tokens
+    context.mint_native(&sender, 100);
+    let token_client = TokenClient::new(env, &context.native_token_client.address);
+
+    // Send to receiver1
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.native_token_client.address,
+            fn_name: "transfer",
+            args: (&sender, &endpoint_client.address, &50i128).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_client.transfer(&sender, &endpoint_client.address, &50);
+
+    let params1 = MessagingParams {
+        dst_eid,
+        receiver: receiver1.clone(),
+        message: message.clone(),
+        options: options.clone(),
+        pay_in_zro: false,
+    };
+
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send",
+            args: (&sender, &params1, &refund_address).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    let receipt1 = endpoint_client.send(&sender, &params1, &refund_address);
+
+    // Send to receiver2
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.native_token_client.address,
+            fn_name: "transfer",
+            args: (&sender, &endpoint_client.address, &50i128).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_client.transfer(&sender, &endpoint_client.address, &50);
+
+    let params2 = MessagingParams { dst_eid, receiver: receiver2.clone(), message, options, pay_in_zro: false };
+
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send",
+            args: (&sender, &params2, &refund_address).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    let receipt2 = endpoint_client.send(&sender, &params2, &refund_address);
+
+    // Verify each receiver has its own nonce tracking
+    assert_eq!(receipt1.nonce, 1);
+    assert_eq!(receipt2.nonce, 1); // First message to receiver2
+
+    // Verify outbound nonces are tracked separately per receiver
+    let nonce1 = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver1);
+    let nonce2 = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver2);
+    assert_eq!(nonce1, 1);
+    assert_eq!(nonce2, 1);
+}
+
+#[test]
+fn test_send_returns_correct_guid() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = soroban_sdk::Address::generate(env);
+    let refund_address = soroban_sdk::Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let options = Bytes::new(env);
+    let fee_recipient = soroban_sdk::Address::generate(env);
+
+    // Set ZRO token (required even when not paying in ZRO due to line 79 in endpoint_v2.rs)
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Setup mock send library
+    let send_lib = context.setup_mock_send_lib(vec![env, dst_eid], 100, 0, fee_recipient);
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, &send_lib));
+    endpoint_client.set_default_send_library(&dst_eid, &send_lib);
+
+    // Get the expected GUID before sending
+    let next_guid = endpoint_client.next_guid(&sender, &dst_eid, &receiver);
+
+    // Mint and transfer tokens
+    context.mint_native(&sender, 100);
+    let token_client = TokenClient::new(env, &context.native_token_client.address);
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.native_token_client.address,
+            fn_name: "transfer",
+            args: (&sender, &endpoint_client.address, &100i128).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_client.transfer(&sender, &endpoint_client.address, &100);
+
+    let params = MessagingParams { dst_eid, receiver, message, options, pay_in_zro: false };
+
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "send",
+            args: (&sender, &params, &refund_address).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let receipt = endpoint_client.send(&sender, &params, &refund_address);
+
+    // Verify the GUID in receipt matches the expected GUID
+    assert_eq!(receipt.guid, next_guid);
+}

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

@@ -0,0 +1,43 @@
+use crate::{events::DelegateSet, storage, tests::endpoint_setup::setup};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_set_delegate() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let oapp = Address::generate(env);
+    let delegate = Address::generate(env);
+
+    // Verify initial state - delegate should not be set
+    let initial_delegate = env.as_contract(&endpoint_client.address, || storage::EndpointStorage::delegate(env, &oapp));
+    assert_eq!(initial_delegate, None, "Initial delegate should be None");
+
+    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);
+
+    // Assert event was published
+    assert_event(env, &endpoint_client.address, DelegateSet { oapp: oapp.clone(), delegate: Some(delegate.clone()) });
+
+    // Verify delegate via public interface
+    let actual_delegate = endpoint_client.delegate(&oapp);
+    assert_eq!(actual_delegate, Some(delegate.clone()), "Delegate should be set");
+
+    // Assert storage change directly
+    let stored_delegate = env.as_contract(&endpoint_client.address, || storage::EndpointStorage::delegate(env, &oapp));
+    assert_eq!(stored_delegate, Some(delegate.clone()), "Storage should contain the delegate address");
+}

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

@@ -0,0 +1,27 @@
+use crate::{events::ZROSet, storage, tests::endpoint_setup::setup};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_set_zro() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    // Verify initial state - ZRO should not be set
+    let initial_zro = env.as_contract(&endpoint_client.address, || storage::EndpointStorage::zro(env));
+    assert_eq!(initial_zro, None, "Initial ZRO should be None");
+
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Assert event was published
+    assert_event(env, &endpoint_client.address, ZROSet { zro: context.zro_token_client.address.clone() });
+
+    // Verify ZRO token is set via public interface
+    let zro_token = endpoint_client.zro();
+    assert_eq!(zro_token, Some(context.zro_token_client.address.clone()));
+
+    // Assert storage change directly
+    let stored_zro = env.as_contract(&endpoint_client.address, || storage::EndpointStorage::zro(env));
+    assert_eq!(stored_zro, Some(context.zro_token_client.address.clone()), "Storage should contain the ZRO address");
+}

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

@@ -0,0 +1,30 @@
+use crate::tests::endpoint_setup::setup;
+use soroban_sdk::testutils::Address as _;
+use utils::ownable::DefaultOwnableStorage;
+
+#[test]
+fn test_transfer_ownership() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let new_owner = soroban_sdk::Address::generate(env);
+
+    // Verify initial owner via public interface
+    let initial_owner = endpoint_client.owner();
+    assert_eq!(initial_owner, Some(context.owner.clone()));
+
+    // Verify initial owner in storage directly
+    let initial_owner = env.as_contract(&endpoint_client.address, || DefaultOwnableStorage::owner(env));
+    assert_eq!(initial_owner, Some(context.owner.clone()), "Initial owner should be in storage");
+
+    context.mock_owner_auth("transfer_ownership", (&new_owner,));
+    endpoint_client.transfer_ownership(&new_owner);
+
+    // Verify new owner via public interface
+    let owner = endpoint_client.owner();
+    assert_eq!(owner, Some(new_owner.clone()));
+
+    // Assert storage change directly
+    let stored_owner = env.as_contract(&endpoint_client.address, || DefaultOwnableStorage::owner(env));
+    assert_eq!(stored_owner, Some(new_owner), "Storage should contain the new owner");
+}