@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,72 +1,50 @@
-use crate::{events::PacketSent, tests::endpoint_setup::setup, MessagingParams};
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    token::TokenClient,
-    vec, Bytes, BytesN, IntoVal,
-};
+use soroban_sdk::{testutils::Address as _, vec, Address, Bytes, BytesN, Env};
 use utils::testing_utils::assert_event;
 
+use crate::{
+    errors::EndpointError,
+    events::PacketSent,
+    tests::endpoint_setup::{setup, TestSetup},
+    MessagingParams, MessagingReceipt,
+};
+
+// Helpers
+fn default_params(env: &Env, dst_eid: u32, pay_in_zro: bool) -> MessagingParams {
+    MessagingParams {
+        dst_eid,
+        receiver: BytesN::from_array(env, &[1u8; 32]),
+        message: Bytes::from_array(env, &[1, 2, 3, 4]),
+        options: Bytes::new(env),
+        pay_in_zro,
+    }
+}
+
+fn send_with_auth<'a>(
+    context: &TestSetup<'a>,
+    sender: &Address,
+    params: &MessagingParams,
+    refund_address: &Address,
+) -> MessagingReceipt {
+    context.mock_auth(sender, "send", (sender, params, refund_address));
+    context.endpoint_client.send(sender, params, refund_address)
+}
+
+// Native Fee Payment
 #[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 sender = Address::generate(env);
+    let refund_address = Address::generate(env);
 
-    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 (send_lib, fee_recipient) = context.setup_default_send_lib(dst_eid, 100, 0);
+    context.fund_endpoint_with_native(&sender, 100);
 
-    let receipt = endpoint_client.send(&sender, &params, &refund_address);
+    let params = default_params(env, dst_eid, false);
+    let receipt = send_with_auth(&context, &sender, &params, &refund_address);
 
     // Verify receipt
     assert_eq!(receipt.nonce, 1);
@@ -78,11 +56,15 @@ fn test_send_with_native_fee_exact_payment() {
     assert_event(
         env,
         &endpoint_client.address,
-        PacketSent { encoded_packet: message, options, send_library: send_lib },
+        PacketSent {
+            encoded_packet: params.message.clone(),
+            options: params.options.clone(),
+            send_library: send_lib.clone(),
+        },
     );
 
     // Verify outbound nonce was incremented
-    let nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    let nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &params.receiver);
     assert_eq!(nonce, 1);
 
     // Verify fee was paid to fee_recipient
@@ -96,57 +78,16 @@ fn test_send_with_native_fee_exact_payment() {
 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 sender = Address::generate(env);
+    let refund_address = 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 (_, fee_recipient) = context.setup_default_send_lib(dst_eid, 100, 0);
 
-    let receipt = endpoint_client.send(&sender, &params, &refund_address);
+    // Overpay native fees
+    context.fund_endpoint_with_native(&sender, 250);
+    let params = default_params(env, dst_eid, false);
+    let receipt = send_with_auth(&context, &sender, &params, &refund_address);
 
     // Verify receipt
     assert_eq!(receipt.nonce, 1);
@@ -160,286 +101,264 @@ fn test_send_with_native_fee_and_refund() {
 }
 
 #[test]
-fn test_send_increments_nonce_sequentially() {
+fn test_send_insufficient_native_fee() {
     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 sender = Address::generate(env);
+    let refund_address = 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: &[],
+    context.setup_default_send_lib(dst_eid, 100, 0);
+
+    // Fund LESS native than required
+    context.fund_endpoint_with_native(&sender, 50);
+
+    let params = default_params(env, dst_eid, false);
+    context.mock_auth(&sender, "send", (&sender, &params, &refund_address));
+    let result = endpoint_client.try_send(&sender, &params, &refund_address);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InsufficientNativeFee.into());
+}
+
+// ZRO Fee Payment
+#[test]
+fn test_send_with_zro_fee() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+    let dst_eid = 2u32;
+    context.setup_zro_with_auth();
+    let (send_lib, fee_recipient) = context.setup_default_send_lib(dst_eid, 50, 25);
+
+    // Fund exact fees
+    context.fund_endpoint_with_native(&sender, 50);
+    context.fund_endpoint_with_zro(&sender, 25);
+
+    let params = default_params(env, dst_eid, true);
+    let receipt = send_with_auth(&context, &sender, &params, &refund_address);
+
+    // Verify receipt
+    assert_eq!(receipt.nonce, 1);
+    assert_eq!(receipt.fee.native_fee, 50);
+    assert_eq!(receipt.fee.zro_fee, 25);
+
+    // Verify PacketSent event was published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketSent {
+            encoded_packet: params.message.clone(),
+            options: params.options.clone(),
+            send_library: send_lib.clone(),
         },
-    }]);
-    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 fees were paid
+    assert_eq!(context.native_token_client.balance(&fee_recipient), 50);
+    assert_eq!(context.zro_token_client.balance(&fee_recipient), 25);
+
+    // Verify no refunds
+    assert_eq!(context.native_token_client.balance(&refund_address), 0);
+    assert_eq!(context.zro_token_client.balance(&refund_address), 0);
+}
+
+#[test]
+fn test_send_with_zro_refund() {
+    let context = setup();
+    let env = &context.env;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+    let dst_eid = 2u32;
+    context.setup_zro_with_auth();
+    let (_, fee_recipient) = context.setup_default_send_lib(dst_eid, 50, 25);
+
+    // Exact native, overpay ZRO to hit refund branch.
+    context.fund_endpoint_with_native(&sender, 50);
+    context.fund_endpoint_with_zro(&sender, 80);
+
+    let params = default_params(env, dst_eid, true);
+    let receipt = send_with_auth(&context, &sender, &params, &refund_address);
+
+    assert_eq!(receipt.nonce, 1);
+    assert_eq!(receipt.fee.native_fee, 50);
+    assert_eq!(receipt.fee.zro_fee, 25);
+
+    // Fee recipient got paid
+    assert_eq!(context.native_token_client.balance(&fee_recipient), 50);
+    assert_eq!(context.zro_token_client.balance(&fee_recipient), 25);
+
+    // Native was exact, ZRO was overpaid => refund 80 - 25 = 55
+    assert_eq!(context.native_token_client.balance(&refund_address), 0);
+    assert_eq!(context.zro_token_client.balance(&refund_address), 55);
+}
+
+#[test]
+fn test_send_pay_in_zro_false_without_zro_set() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+    let dst_eid = 2u32;
+
+    // Ensure ZRO is not set; pay_in_zro=false should not require it.
+    assert_eq!(endpoint_client.zro(), None);
+
+    let (_, fee_recipient) = context.setup_default_send_lib(dst_eid, 100, 0);
+    context.fund_endpoint_with_native(&sender, 100);
+
+    let params = default_params(env, dst_eid, false);
+    let receipt = send_with_auth(&context, &sender, &params, &refund_address);
+
+    assert_eq!(receipt.nonce, 1);
+    assert_eq!(receipt.fee.native_fee, 100);
+    assert_eq!(receipt.fee.zro_fee, 0);
+    assert_eq!(context.native_token_client.balance(&fee_recipient), 100);
+    assert_eq!(context.native_token_client.balance(&refund_address), 0);
+}
+
+#[test]
+fn test_send_zro_unavailable_when_pay_in_zro() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // ZRO is intentionally unset
+    assert_eq!(endpoint_client.zro(), None);
+
+    // ZRO check happens before send lib resolution; we don't need to setup a send lib.
+    let params = default_params(env, 998u32, true);
+    context.mock_auth(&sender, "send", (&sender, &params, &refund_address));
+    let result = endpoint_client.try_send(&sender, &params, &refund_address);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::ZroUnavailable.into());
+}
+
+#[test]
+fn test_send_zero_zro_fee_when_pay_in_zro_true() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+    let dst_eid = 2u32;
+
+    // Set ZRO token so we pass the send() pre-check, but do NOT transfer any ZRO to the endpoint.
+    context.setup_zro_with_auth();
+
+    // Configure send lib with zero fees, but pay_in_zro=true triggers the ZeroZROFee guard.
+    context.setup_default_send_lib(dst_eid, 0, 0);
+
+    let params = default_params(env, dst_eid, true);
+    context.mock_auth(&sender, "send", (&sender, &params, &refund_address));
+    let result = endpoint_client.try_send(&sender, &params, &refund_address);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::ZeroZroFee.into());
+}
+
+#[test]
+fn test_send_insufficient_zro_fee() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+    let dst_eid = 2u32;
+
+    // Set ZRO token
+    context.setup_zro_with_auth();
+
+    // Setup send lib that requires 25 ZRO, 0 native
+    context.setup_default_send_lib(dst_eid, 0, 25);
+
+    // Transfer LESS ZRO than needed (only 10)
+    context.fund_endpoint_with_zro(&sender, 10);
+
+    let params = default_params(env, dst_eid, true);
+    context.mock_auth(&sender, "send", (&sender, &params, &refund_address));
+    let result = endpoint_client.try_send(&sender, &params, &refund_address);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::InsufficientZroFee.into());
+}
+
+// Nonce Management
+#[test]
+fn test_send_increments_nonce_sequentially() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+    let dst_eid = 2u32;
+    context.setup_default_send_lib(dst_eid, 50, 0);
+    let params = default_params(env, dst_eid, false);
+
+    for expected_nonce in 1..=3u64 {
+        context.fund_endpoint_with_native(&sender, 50);
+        let receipt = send_with_auth(&context, &sender, &params, &refund_address);
+        assert_eq!(receipt.nonce, expected_nonce);
+    }
 
     // Verify final outbound nonce
-    let final_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &receiver);
+    let final_nonce = endpoint_client.outbound_nonce(&sender, &dst_eid, &params.receiver);
     assert_eq!(final_nonce, 3);
 }
 
 #[test]
-fn test_send_with_custom_send_library() {
+fn test_next_guid_matches_send_receipt_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 sender = Address::generate(env);
+    let refund_address = 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);
+    context.setup_default_send_lib(dst_eid, 100, 0);
+    let params = default_params(env, dst_eid, false);
 
-    // 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: &[],
-        },
-    }]);
+    // Get the expected GUID before sending
+    let next_guid = endpoint_client.next_guid(&sender, &dst_eid, &params.receiver);
 
-    let receipt = endpoint_client.send(&sender, &params, &refund_address);
+    // Fund endpoint with native fee
+    context.fund_endpoint_with_native(&sender, 100);
 
-    // Verify receipt uses custom library fee (200, not 100)
-    assert_eq!(receipt.fee.native_fee, 200);
+    let receipt = send_with_auth(&context, &sender, &params, &refund_address);
 
-    // 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);
+    // Verify the GUID in receipt matches the expected GUID
+    assert_eq!(receipt.guid, next_guid);
 }
 
+// Receiver Management
 #[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 sender = Address::generate(env);
+    let refund_address = 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);
+    context.setup_default_send_lib(dst_eid, 50, 0);
 
-    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);
+    let mut params1 = default_params(env, dst_eid, false);
+    params1.receiver = receiver1.clone();
+    context.fund_endpoint_with_native(&sender, 50);
+    let receipt1 = send_with_auth(&context, &sender, &params1, &refund_address);
+
+    let mut params2 = default_params(env, dst_eid, false);
+    params2.receiver = receiver2.clone();
+    context.fund_endpoint_with_native(&sender, 50);
+    let receipt2 = send_with_auth(&context, &sender, &params2, &refund_address);
 
     // Verify each receiver has its own nonce tracking
     assert_eq!(receipt1.nonce, 1);
@@ -452,62 +371,113 @@ fn test_send_to_different_receivers() {
     assert_eq!(nonce2, 1);
 }
 
+// Send Library Management
 #[test]
-fn test_send_returns_correct_guid() {
+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 sender = Address::generate(env);
+    let refund_address = 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 (_, default_fee_recipient) = context.setup_default_send_lib(dst_eid, 100, 0);
 
-    let receipt = endpoint_client.send(&sender, &params, &refund_address);
+    // Setup custom send library with different fee (200)
+    let custom_fee_recipient = Address::generate(env);
+    let custom_lib = context.setup_mock_send_lib(vec![&context.env, dst_eid], 200, 0, custom_fee_recipient.clone());
+    context.register_library_with_auth(&custom_lib);
 
-    // Verify the GUID in receipt matches the expected GUID
-    assert_eq!(receipt.guid, next_guid);
+    // Set custom library for this sender
+    let custom_lib_option = Some(custom_lib.clone());
+    context.mock_auth(&sender, "set_send_library", (&sender, &sender, &dst_eid, &custom_lib_option));
+    endpoint_client.set_send_library(&sender, &sender, &dst_eid, &custom_lib_option);
+
+    // Fund endpoint with native token for custom library fee
+    context.fund_endpoint_with_native(&sender, 200);
+
+    let params = default_params(env, dst_eid, false);
+    let receipt = send_with_auth(&context, &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);
+}
+
+// Options handling
+#[test]
+fn test_send_with_non_empty_options_emits_event_and_charges_fee() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+    let dst_eid = 2u32;
+
+    // Non-empty options (simulating executor/DVN options)
+    // Format example: [worker_id (1 byte), option_size (2 bytes), option_data...]
+    let options = Bytes::from_array(env, &[1u8, 0u8, 4u8, 9u8, 8u8, 7u8, 6u8]);
+
+    let (send_lib, fee_recipient) = context.setup_default_send_lib(dst_eid, 100, 0);
+    context.fund_endpoint_with_native(&sender, 100);
+
+    let mut params = default_params(env, dst_eid, false);
+    params.options = options.clone();
+
+    let receipt = send_with_auth(&context, &sender, &params, &refund_address);
+
+    assert_eq!(receipt.nonce, 1);
+    assert_eq!(receipt.fee.native_fee, 100);
+    assert_eq!(receipt.fee.zro_fee, 0);
+
+    // Verify PacketSent event captures options and encoded packet.
+    assert_event(
+        env,
+        &endpoint_client.address,
+        PacketSent { encoded_packet: params.message.clone(), options: options.clone(), send_library: send_lib.clone() },
+    );
+
+    // Fee was paid and there was no refund.
+    assert_eq!(context.native_token_client.balance(&fee_recipient), 100);
+    assert_eq!(context.native_token_client.balance(&refund_address), 0);
+}
+
+#[test]
+fn test_send_default_send_lib_unavailable() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+    let dst_eid = 999u32; // unique eid with no default send library
+
+    // Ensure no default send library is set
+    assert_eq!(endpoint_client.default_send_library(&dst_eid), None);
+
+    let params = default_params(env, dst_eid, false);
+    context.mock_auth(&sender, "send", (&sender, &params, &refund_address));
+    let result = endpoint_client.try_send(&sender, &params, &refund_address);
+    assert_eq!(result.err().unwrap().ok().unwrap(), EndpointError::DefaultSendLibUnavailable.into());
+}
+
+// Authorization
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_send_unauthorized() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // No mock auth for `sender` => should panic on `sender.require_auth()`
+    let params = default_params(env, 2u32, false);
+    endpoint_client.send(&sender, &params, &refund_address);
 }