@layerzerolabs/protocol-stellar-v2 0.2.9 → 0.2.11

package/contracts/oapps/oft/src/tests/extensions/test_oft_fee.rs

@@ -0,0 +1,749 @@
+//! Tests for the OFT fee extension functionality.
+//!
+//! Tests verify:
+//! - Fee configuration (default fee, per-destination fee)
+//! - Fee calculation in quote_oft
+//! - Fee deduction and transfer in send
+//! - Fee deposit address configuration
+
+use crate::extensions::oft_fee::OFTFeeError;
+use crate::tests::test_utils::{create_origin, create_recipient_address, encode_oft_message};
+use crate::utils::address_to_bytes32;
+use endpoint_v2::MessagingFee;
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env, IntoVal};
+
+use super::setup::ExtensiveOFTTestSetup;
+
+// ==================== Default Fee Configuration Tests ====================
+
+#[test]
+fn test_initial_default_fee_is_zero() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    assert_eq!(setup.default_fee_bps(), 0);
+}
+
+#[test]
+fn test_set_default_fee_bps() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    setup.set_default_fee_bps(100); // 1%
+    assert_eq!(setup.default_fee_bps(), 100);
+}
+
+#[test]
+fn test_set_default_fee_bps_max() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Max fee is 10000 BPS (100%)
+    setup.set_default_fee_bps(10000);
+    assert_eq!(setup.default_fee_bps(), 10000);
+}
+
+#[test]
+fn test_set_default_fee_bps_exceeds_max() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Should fail - exceeds 100%
+    let result = setup.try_set_default_fee_bps(10001);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
+}
+
+#[test]
+fn test_set_default_fee_bps_same_value_fails() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    setup.set_default_fee_bps(100);
+    // Setting same value should fail
+    let result = setup.try_set_default_fee_bps(100);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
+}
+
+// ==================== Destination Fee Configuration Tests ====================
+
+#[test]
+fn test_set_fee_bps_for_destination() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+    setup.set_fee_bps(dst_eid, 200); // 2%
+
+    assert!(setup.has_fee_bps(dst_eid));
+    assert_eq!(setup.fee_bps(dst_eid), 200);
+}
+
+#[test]
+fn test_set_fee_bps_max_value() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+
+    // Set max fee (100%)
+    setup.set_fee_bps(dst_eid, 10000);
+    assert_eq!(setup.fee_bps(dst_eid), 10000);
+}
+
+#[test]
+fn test_set_fee_bps_exceeds_max() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+
+    // Try to set fee > 100% (> 10000 BPS)
+    let result = setup.try_set_fee_bps(dst_eid, 10001);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
+}
+
+#[test]
+fn test_set_fee_bps_same_value_for_destination_fails() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+    let fee_bps = 200u64; // 2%
+
+    // Set fee for destination
+    setup.set_fee_bps(dst_eid, fee_bps);
+    assert_eq!(setup.fee_bps(dst_eid), fee_bps);
+
+    // Try to set same fee again - should fail with SameValue
+    let result = setup.try_set_fee_bps(dst_eid, fee_bps);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
+}
+
+#[test]
+fn test_update_fee_bps_for_destination() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+
+    // Set initial fee
+    setup.set_fee_bps(dst_eid, 100);
+    assert_eq!(setup.fee_bps(dst_eid), 100);
+
+    // Update to different fee
+    setup.set_fee_bps(dst_eid, 200);
+    assert_eq!(setup.fee_bps(dst_eid), 200);
+}
+
+#[test]
+fn test_unset_fee_bps() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+    setup.set_fee_bps(dst_eid, 200);
+    assert!(setup.has_fee_bps(dst_eid));
+
+    setup.unset_fee_bps(dst_eid);
+    assert!(!setup.has_fee_bps(dst_eid));
+}
+
+#[test]
+fn test_unset_fee_bps_not_found() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+
+    // Try to unset fee for destination that doesn't have one - should fail with NotFound
+    let result = setup.try_unset_fee_bps(dst_eid);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTFeeError::NotFound.into());
+}
+
+// ==================== Effective Fee Tests ====================
+
+#[test]
+fn test_has_oft_fee_returns_true_when_fee_configured() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Initially no fee is configured
+    let dst_eid = 100u32;
+    assert_eq!(setup.effective_fee_bps(dst_eid), 0);
+
+    // Set default fee
+    setup.set_default_fee_bps(100); // 1%
+
+    // Now has_fee_bps should return true since the default fee is non-zero
+    assert!(setup.has_fee_bps(dst_eid));
+}
+
+#[test]
+fn test_has_oft_fee_returns_false_when_no_fee() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+
+    // No fee configured - should return false
+    assert!(!setup.has_fee_bps(dst_eid));
+}
+
+#[test]
+fn test_has_oft_fee_uses_destination_specific_fee() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid_1 = 100u32;
+    let dst_eid_2 = 200u32;
+
+    // Set destination-specific fee for dst_eid_1 only
+    setup.set_fee_bps(dst_eid_1, 100); // 1%
+
+    // dst_eid_1 should have fee
+    assert!(setup.has_fee_bps(dst_eid_1));
+
+    // dst_eid_2 should not have fee (no default, no specific)
+    assert!(!setup.has_fee_bps(dst_eid_2));
+}
+
+#[test]
+fn test_effective_fee_uses_destination_over_default() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    setup.set_default_fee_bps(100); // 1% default
+
+    let dst_eid = 100u32;
+    setup.set_fee_bps(dst_eid, 200); // 2% for specific destination
+
+    // Effective fee should use destination-specific fee
+    assert_eq!(setup.effective_fee_bps(dst_eid), 200);
+}
+
+#[test]
+fn test_effective_fee_falls_back_to_default() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    setup.set_default_fee_bps(100); // 1% default
+
+    let dst_eid = 100u32;
+    // No destination-specific fee set
+
+    // Effective fee should use default
+    assert_eq!(setup.effective_fee_bps(dst_eid), 100);
+}
+
+// ==================== Fee Deposit Address Tests ====================
+
+#[test]
+fn test_set_fee_deposit_address() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+
+    assert_eq!(setup.fee_deposit_address(), fee_collector);
+}
+
+#[test]
+fn test_set_fee_deposit_address_same_value_fails() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let fee_collector = create_recipient_address(&env);
+
+    // Set fee deposit address
+    setup.set_fee_deposit_address(&fee_collector);
+    assert_eq!(setup.fee_deposit_address(), fee_collector);
+
+    // Try to set same address again - should fail with SameValue
+    let result = setup.try_set_fee_deposit_address(&fee_collector);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
+}
+
+#[test]
+fn test_update_fee_deposit_address() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let fee_collector_1 = create_recipient_address(&env);
+    let fee_collector_2 = create_recipient_address(&env);
+
+    // Set initial address
+    setup.set_fee_deposit_address(&fee_collector_1);
+    assert_eq!(setup.fee_deposit_address(), fee_collector_1);
+
+    // Update to different address
+    setup.set_fee_deposit_address(&fee_collector_2);
+    assert_eq!(setup.fee_deposit_address(), fee_collector_2);
+}
+
+// ==================== quote_oft Tests (Fee Calculation) ====================
+
+#[test]
+fn test_quote_oft_no_fee() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee deposit address (required by ExtensiveOFT even with no fee)
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+
+    let dst_eid = 100u32;
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(dst_eid, &peer);
+
+    let amount_ld = 1_000_000i128;
+    let send_param = setup.create_send_param(dst_eid, amount_ld, amount_ld);
+
+    let receipt = setup.quote_oft(&send_param);
+
+    // No fee configured, amounts should be equal
+    assert_eq!(receipt.amount_sent_ld, amount_ld);
+    assert_eq!(receipt.amount_received_ld, amount_ld);
+}
+
+#[test]
+fn test_quote_oft_with_default_fee() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee deposit address (required for fee to be applied)
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+
+    // Set 1% default fee (100 BPS)
+    setup.set_default_fee_bps(100);
+
+    let dst_eid = 100u32;
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(dst_eid, &peer);
+
+    let dust = 5i128;
+    let amount_ld = 1_000_000i128 + dust; // dust will be charged as a fee
+                                          // min_amount_ld should account for fee
+    let expected_after_fee = 990_000i128; // 1% fee
+    let send_param = setup.create_send_param(dst_eid, amount_ld, expected_after_fee);
+
+    let receipt = setup.quote_oft(&send_param);
+
+    // Amount sent is original, amount received is after fee
+    assert_eq!(receipt.amount_sent_ld, amount_ld);
+    assert_eq!(receipt.amount_received_ld, expected_after_fee);
+}
+
+#[test]
+fn test_quote_oft_with_destination_fee() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee deposit address
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+
+    // Set 1% default fee and 2% for specific destination
+    setup.set_default_fee_bps(100);
+    let dst_eid = 100u32;
+    setup.set_fee_bps(dst_eid, 200); // 2%
+
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(dst_eid, &peer);
+
+    let amount_ld = 1_000_000i128;
+    let expected_after_fee = 980_000i128; // 2% fee
+    let send_param = setup.create_send_param(dst_eid, amount_ld, expected_after_fee);
+
+    let receipt = setup.quote_oft(&send_param);
+
+    // Should use destination-specific 2% fee
+    assert_eq!(receipt.amount_sent_ld, amount_ld);
+    assert_eq!(receipt.amount_received_ld, expected_after_fee);
+}
+
+#[test]
+fn test_quote_oft_fee_calculation_precision() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee deposit address
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+
+    // Set 0.5% fee (50 BPS)
+    setup.set_default_fee_bps(50);
+
+    let dst_eid = 100u32;
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(dst_eid, &peer);
+
+    let amount_ld = 1_000_000i128;
+    // 0.5% of 1_000_000 = 5_000 fee
+    let expected_after_fee = 995_000i128;
+    let send_param = setup.create_send_param(dst_eid, amount_ld, expected_after_fee);
+
+    let receipt = setup.quote_oft(&send_param);
+
+    assert_eq!(receipt.amount_sent_ld, amount_ld);
+    assert_eq!(receipt.amount_received_ld, expected_after_fee);
+}
+
+// ==================== quote_send Tests (Fee) ====================
+
+#[test]
+fn test_quote_send_with_fee() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee deposit address and fee
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+    setup.set_default_fee_bps(100); // 1%
+
+    let sender = Address::generate(&env);
+    let dst_eid = 100u32;
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(dst_eid, &peer);
+
+    let amount_ld = 1_000_000i128;
+    let expected_after_fee = 990_000i128;
+    let send_param = setup.create_send_param(dst_eid, amount_ld, expected_after_fee);
+
+    // quote_send should work with fees configured
+    let msg_fee = setup.quote_send(&sender, &send_param, false);
+    assert!(msg_fee.native_fee > 0);
+}
+
+// ==================== send Tests (Fee Transfer) ====================
+
+#[test]
+fn test_quote_oft_with_fee_without_deposit_address_fails() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee rate but no fee deposit address
+    setup.set_default_fee_bps(100); // 1%
+
+    let dst_eid = 100u32;
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(dst_eid, &peer);
+
+    let amount_ld = 1_000_000i128;
+    let expected_after_fee = 990_000i128;
+    let send_param = setup.create_send_param(dst_eid, amount_ld, expected_after_fee);
+
+    // quote_oft should fail because fee deposit address is not set
+    let result = setup.try_quote_oft(&send_param);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeDepositAddress.into());
+}
+
+#[test]
+fn test_send_with_fee_transfers_to_collector() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee deposit address
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+
+    // Set 1% fee
+    setup.set_default_fee_bps(100);
+
+    let sender = Address::generate(&env);
+    let dst_eid = 100u32;
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(dst_eid, &peer);
+
+    let amount_ld = 1_000_000i128;
+    let expected_fee = 10_000i128; // 1%
+    let expected_after_fee = 990_000i128;
+
+    setup.fund_tokens(&sender, amount_ld);
+    setup.fund_native_fees(&sender, setup.native_fee);
+
+    let initial_collector_balance = setup.token_client.balance(&fee_collector);
+
+    let send_param = setup.create_send_param(dst_eid, amount_ld, expected_after_fee);
+    let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
+    let oft_receipt = setup.quote_oft(&send_param);
+
+    // Use send_with_fee which includes fee transfer auth
+    let (_, receipt) = setup.send_with_fee(&sender, &send_param, &fee, &sender, &oft_receipt, &fee_collector);
+
+    // Verify receipt
+    assert_eq!(receipt.amount_sent_ld, amount_ld);
+    assert_eq!(receipt.amount_received_ld, expected_after_fee);
+
+    // Verify fee was transferred to collector
+    assert_eq!(setup.token_client.balance(&fee_collector), initial_collector_balance + expected_fee);
+
+    // Verify sender's tokens were burned (amount_sent_ld)
+    assert_eq!(setup.token_client.balance(&sender), 0);
+}
+
+#[test]
+fn test_send_without_fee_no_transfer() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee deposit address (required by ExtensiveOFT)
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+
+    // No fee rate configured (default is 0)
+    let sender = Address::generate(&env);
+    let dst_eid = 100u32;
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(dst_eid, &peer);
+
+    let amount_ld = 1_000_000i128;
+    setup.fund_tokens(&sender, amount_ld);
+    setup.fund_native_fees(&sender, setup.native_fee);
+
+    let send_param = setup.create_send_param(dst_eid, amount_ld, amount_ld);
+    let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
+    let oft_receipt = setup.quote_oft(&send_param);
+
+    // Use regular send (no fee transfer needed since fee is 0)
+    let (_, receipt) = setup.send(&sender, &send_param, &fee, &sender, &oft_receipt);
+
+    // Amounts should be equal (no fee)
+    assert_eq!(receipt.amount_sent_ld, amount_ld);
+    assert_eq!(receipt.amount_received_ld, amount_ld);
+}
+
+#[test]
+fn test_send_with_different_destination_fees() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee deposit address
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+
+    // Set different fees for different destinations
+    let dst_eid_1 = 100u32;
+    let dst_eid_2 = 200u32;
+    setup.set_fee_bps(dst_eid_1, 100); // 1%
+    setup.set_fee_bps(dst_eid_2, 500); // 5%
+
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(dst_eid_1, &peer);
+    setup.set_peer(dst_eid_2, &peer);
+
+    let sender = Address::generate(&env);
+    let amount_ld = 1_000_000i128;
+    let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
+
+    // First send to dst_eid_1 (1% fee)
+    setup.fund_tokens(&sender, amount_ld);
+    setup.fund_native_fees(&sender, setup.native_fee);
+
+    let expected_after_fee_1 = 990_000i128;
+    let send_param_1 = setup.create_send_param(dst_eid_1, amount_ld, expected_after_fee_1);
+    let oft_receipt_1 = setup.quote_oft(&send_param_1);
+
+    let (_, receipt_1) = setup.send_with_fee(&sender, &send_param_1, &fee, &sender, &oft_receipt_1, &fee_collector);
+    assert_eq!(receipt_1.amount_received_ld, expected_after_fee_1);
+
+    // Second send to dst_eid_2 (5% fee)
+    setup.fund_tokens(&sender, amount_ld);
+    setup.fund_native_fees(&sender, setup.native_fee);
+
+    let expected_after_fee_2 = 950_000i128;
+    let send_param_2 = setup.create_send_param(dst_eid_2, amount_ld, expected_after_fee_2);
+    let oft_receipt_2 = setup.quote_oft(&send_param_2);
+
+    let (_, receipt_2) = setup.send_with_fee(&sender, &send_param_2, &fee, &sender, &oft_receipt_2, &fee_collector);
+    assert_eq!(receipt_2.amount_received_ld, expected_after_fee_2);
+}
+
+// ==================== lz_receive Tests (No Fee on Inbound) ====================
+
+#[test]
+fn test_lz_receive_no_fee_on_inbound() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Set fee (only applies to outbound)
+    let fee_collector = create_recipient_address(&env);
+    setup.set_fee_deposit_address(&fee_collector);
+    setup.set_default_fee_bps(100); // 1%
+
+    let executor = Address::generate(&env);
+    let recipient = create_recipient_address(&env);
+    let src_eid = 100u32;
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    setup.set_peer(src_eid, &peer);
+
+    let amount_sd = 1_000_000u64;
+    let recipient_bytes32 = address_to_bytes32(&recipient);
+    let message = encode_oft_message(&env, &recipient_bytes32, amount_sd);
+
+    let guid = BytesN::from_array(&env, &[1u8; 32]);
+    let origin = create_origin(src_eid, &peer, 1);
+    let extra_data = Bytes::new(&env);
+
+    let initial_balance = setup.token_client.balance(&recipient);
+    let initial_collector_balance = setup.token_client.balance(&fee_collector);
+
+    setup.lz_receive(&executor, &origin, &guid, &message, &extra_data, 0);
+
+    // Recipient should receive full amount (no fee on inbound)
+    let conversion_rate = setup.oft.decimal_conversion_rate();
+    let expected_amount_ld = (amount_sd as i128) * conversion_rate;
+    assert_eq!(setup.token_client.balance(&recipient), initial_balance + expected_amount_ld);
+
+    // Fee collector should not receive anything on inbound
+    assert_eq!(setup.token_client.balance(&fee_collector), initial_collector_balance);
+}
+
+// ==================== Authentication Tests ====================
+
+#[test]
+fn test_set_default_fee_bps_requires_owner_auth() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    // Try to set default fee without auth (no auth provided)
+    let result = setup.oft.try_set_default_fee_bps(&100);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_set_default_fee_bps_wrong_auth_fails() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let non_owner = Address::generate(&env);
+
+    // Try to set default fee with wrong auth (non-owner)
+    env.mock_auths(&[soroban_sdk::testutils::MockAuth {
+        address: &non_owner,
+        invoke: &soroban_sdk::testutils::MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_default_fee_bps",
+            args: (100u64,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    let result = setup.oft.try_set_default_fee_bps(&100);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_set_fee_bps_requires_owner_auth() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+
+    // Try to set fee bps without auth
+    let result = setup.oft.try_set_fee_bps(&dst_eid, &200);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_set_fee_bps_wrong_auth_fails() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let non_owner = Address::generate(&env);
+    let dst_eid = 100u32;
+
+    // Try to set fee bps with wrong auth (non-owner)
+    env.mock_auths(&[soroban_sdk::testutils::MockAuth {
+        address: &non_owner,
+        invoke: &soroban_sdk::testutils::MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_fee_bps",
+            args: (dst_eid, 200u64).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    let result = setup.oft.try_set_fee_bps(&dst_eid, &200);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_unset_fee_bps_requires_owner_auth() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let dst_eid = 100u32;
+
+    // First set fee bps as owner
+    setup.set_fee_bps(dst_eid, 200);
+    assert!(setup.has_fee_bps(dst_eid));
+
+    // Try to unset fee bps without auth
+    let result = setup.oft.try_unset_fee_bps(&dst_eid);
+    assert!(result.is_err());
+
+    // Fee should still be set
+    assert!(setup.has_fee_bps(dst_eid));
+}
+
+#[test]
+fn test_unset_fee_bps_wrong_auth_fails() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let non_owner = Address::generate(&env);
+    let dst_eid = 100u32;
+
+    // First set fee bps as owner
+    setup.set_fee_bps(dst_eid, 200);
+
+    // Try to unset fee bps with wrong auth (non-owner)
+    env.mock_auths(&[soroban_sdk::testutils::MockAuth {
+        address: &non_owner,
+        invoke: &soroban_sdk::testutils::MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "unset_fee_bps",
+            args: (dst_eid,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    let result = setup.oft.try_unset_fee_bps(&dst_eid);
+    assert!(result.is_err());
+
+    // Fee should still be set
+    assert!(setup.has_fee_bps(dst_eid));
+}
+
+#[test]
+fn test_set_fee_deposit_address_requires_owner_auth() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let fee_collector = create_recipient_address(&env);
+
+    // Try to set fee deposit address without auth
+    let result = setup.oft.try_set_fee_deposit_address(&fee_collector);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_set_fee_deposit_address_wrong_auth_fails() {
+    let env = Env::default();
+    let setup = ExtensiveOFTTestSetup::new(&env);
+
+    let non_owner = Address::generate(&env);
+    let fee_collector = create_recipient_address(&env);
+
+    // Try to set fee deposit address with wrong auth (non-owner)
+    env.mock_auths(&[soroban_sdk::testutils::MockAuth {
+        address: &non_owner,
+        invoke: &soroban_sdk::testutils::MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_fee_deposit_address",
+            args: (&fee_collector,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    let result = setup.oft.try_set_fee_deposit_address(&fee_collector);
+    assert!(result.is_err());
+}