@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

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

@@ -0,0 +1,447 @@
+extern crate std;
+
+use crate as oft;
+use crate::extensions::rate_limiter::{Direction, RateLimitConfig, RateLimitError, RateLimiter, RateLimiterInternal};
+use soroban_sdk::{contract, contractimpl, testutils::Ledger as _, Address, Env};
+use utils::auth::Auth;
+
+// ============================================================================
+// Test Contract
+// ============================================================================
+
+#[contract]
+struct RateLimiterTestContract;
+
+impl Auth for RateLimiterTestContract {
+    fn authorizer(env: &Env) -> Address {
+        env.current_contract_address()
+    }
+}
+
+impl RateLimiterInternal for RateLimiterTestContract {}
+
+#[contractimpl(contracttrait)]
+impl RateLimiter for RateLimiterTestContract {}
+
+#[contractimpl]
+impl RateLimiterTestContract {
+    pub fn consume(env: Env, direction: Direction, eid: u32, amount: i128) {
+        <Self as RateLimiterInternal>::__consume_rate_limit_capacity(&env, &direction, eid, amount)
+    }
+
+    pub fn release(env: Env, direction: Direction, eid: u32, amount: i128) {
+        <Self as RateLimiterInternal>::__release_rate_limit_capacity(&env, &direction, eid, amount)
+    }
+}
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+struct TestSetup {
+    env: Env,
+    client: RateLimiterTestContractClient<'static>,
+}
+
+fn setup() -> TestSetup {
+    let env = Env::default();
+    // Enable mock_all_auths_allowing_non_root_auth for all tests to bypass authorization checks
+    // including sub-contract invocations
+    env.mock_all_auths_allowing_non_root_auth();
+
+    let contract_id = env.register(RateLimiterTestContract, ());
+    let client = RateLimiterTestContractClient::new(&env, &contract_id);
+    TestSetup { env, client }
+}
+
+fn config(limit: i128, window_seconds: u64) -> RateLimitConfig {
+    RateLimitConfig { limit, window_seconds }
+}
+
+// ============================================================================
+// No Config Tests
+// ============================================================================
+
+#[test]
+fn test_no_config_is_unlimited() {
+    let TestSetup { client, .. } = setup();
+
+    assert_eq!(client.rate_limit_capacity(&Direction::Outbound, &1u32), i128::MAX);
+    assert_eq!(client.rate_limit_in_flight(&Direction::Outbound, &1u32), 0);
+}
+
+#[test]
+fn test_no_config_consume_and_release_are_noop() {
+    let TestSetup { client, .. } = setup();
+
+    client.consume(&Direction::Outbound, &1u32, &999i128);
+    assert_eq!(client.rate_limit_in_flight(&Direction::Outbound, &1u32), 0);
+
+    client.release(&Direction::Outbound, &1u32, &999i128);
+    assert_eq!(client.rate_limit_in_flight(&Direction::Outbound, &1u32), 0);
+}
+
+// ============================================================================
+// Set Rate Limit Tests
+// ============================================================================
+
+#[test]
+fn test_set_rate_limit_rejects_invalid_config() {
+    let TestSetup { client, .. } = setup();
+
+    // Invalid: window_seconds == 0
+    let res = client.try_set_rate_limit(&Direction::Outbound, &1u32, &Some(config(10, 0)));
+    assert_eq!(res.err().unwrap().ok().unwrap(), RateLimitError::InvalidConfig.into());
+
+    // Invalid: limit < 0
+    let res2 = client.try_set_rate_limit(&Direction::Outbound, &1u32, &Some(config(-1, 10)));
+    assert_eq!(res2.err().unwrap().ok().unwrap(), RateLimitError::InvalidConfig.into());
+}
+
+#[test]
+fn test_set_rate_limit_rejects_same_value() {
+    let TestSetup { client, .. } = setup();
+
+    // SameValue when removing a non-existent config.
+    let res = client.try_set_rate_limit(&Direction::Outbound, &1u32, &None);
+    assert_eq!(res.err().unwrap().ok().unwrap(), RateLimitError::SameValue.into());
+
+    // Set a valid config; setting same again should be SameValue.
+    let cfg = config(100, 10);
+    client.set_rate_limit(&Direction::Outbound, &1u32, &Some(cfg.clone()));
+    let res2 = client.try_set_rate_limit(&Direction::Outbound, &1u32, &Some(cfg));
+    assert_eq!(res2.err().unwrap().ok().unwrap(), RateLimitError::SameValue.into());
+}
+
+// ============================================================================
+// Consume and Release Tests
+// ============================================================================
+
+#[test]
+fn test_consume_rejects_negative_amount() {
+    let TestSetup { client, .. } = setup();
+
+    client.set_rate_limit(&Direction::Outbound, &1u32, &Some(config(100, 100)));
+
+    let res = client.try_consume(&Direction::Outbound, &1u32, &-1i128);
+    assert_eq!(res.err().unwrap().ok().unwrap(), RateLimitError::InvalidAmount.into());
+}
+
+#[test]
+fn test_release_rejects_negative_amount() {
+    let TestSetup { client, .. } = setup();
+
+    client.set_rate_limit(&Direction::Outbound, &1u32, &Some(config(100, 100)));
+
+    let res = client.try_release(&Direction::Outbound, &1u32, &-1i128);
+    assert_eq!(res.err().unwrap().ok().unwrap(), RateLimitError::InvalidAmount.into());
+}
+
+#[test]
+fn test_consume_within_capacity() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 77u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 100)));
+
+    client.consume(&direction, &eid, &60i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 60);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 40);
+}
+
+#[test]
+fn test_consume_exceeds_capacity() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 77u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 100)));
+    client.consume(&direction, &eid, &60i128);
+
+    let res = client.try_consume(&direction, &eid, &41i128);
+    assert_eq!(res.err().unwrap().ok().unwrap(), RateLimitError::ExceededRateLimit.into());
+}
+
+#[test]
+fn test_release_reduces_in_flight() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 77u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 100)));
+    client.consume(&direction, &eid, &60i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 60);
+
+    client.release(&direction, &eid, &10i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 50);
+
+    // Release more than in-flight clamps to 0.
+    client.release(&direction, &eid, &999i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 0);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 100);
+}
+
+// ============================================================================
+// Decay Tests
+// ============================================================================
+
+#[test]
+fn test_decay_reduces_in_flight_over_time() {
+    let TestSetup { env, client } = setup();
+    let direction = Direction::Outbound;
+    let eid = 5u32;
+
+    env.ledger().set_timestamp(1_000);
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 10)));
+
+    client.consume(&direction, &eid, &100i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 100);
+
+    // Advance 5 seconds => decay 50.
+    env.ledger().set_timestamp(1_005);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 50);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 50);
+}
+
+#[test]
+fn test_timestamp_regression_errors() {
+    let TestSetup { env, client } = setup();
+    let direction = Direction::Outbound;
+    let eid = 5u32;
+
+    env.ledger().set_timestamp(1_000);
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 10)));
+    client.consume(&direction, &eid, &100i128);
+
+    // Set timestamp backwards => should error.
+    env.ledger().set_timestamp(999);
+    let res = client.try_rate_limit_in_flight(&direction, &eid);
+    assert_eq!(res.err().unwrap().ok().unwrap(), RateLimitError::InvalidTimestamp.into());
+}
+
+// ============================================================================
+// Config Update Tests
+// ============================================================================
+
+#[test]
+fn test_updating_config_checkpoints_in_flight() {
+    let TestSetup { env, client } = setup();
+    let direction = Direction::Outbound;
+    let eid = 42u32;
+
+    env.ledger().set_timestamp(1_000);
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 10)));
+    client.consume(&direction, &eid, &100i128);
+
+    // Move forward, then update config.
+    env.ledger().set_timestamp(1_005);
+    client.set_rate_limit(&direction, &eid, &Some(config(200, 20)));
+
+    // At t=1005, old config would have decayed to 50.
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 50);
+
+    // After 10 more seconds, new config decay should clear it.
+    env.ledger().set_timestamp(1_015);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 0);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 200);
+}
+
+#[test]
+fn test_reducing_limit_below_in_flight_clamps_capacity() {
+    let TestSetup { env, client } = setup();
+    let direction = Direction::Inbound;
+    let eid = 123u32;
+
+    env.ledger().set_timestamp(1_000);
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 100)));
+    client.consume(&direction, &eid, &90i128);
+
+    // Reduce limit below in-flight.
+    client.set_rate_limit(&direction, &eid, &Some(config(50, 100)));
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 0);
+}
+
+#[test]
+fn test_removing_rate_limit_makes_unlimited() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Inbound;
+    let eid = 321u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config(10, 10)));
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 10);
+
+    client.set_rate_limit(&direction, &eid, &None);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), i128::MAX);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 0);
+}
+
+// ============================================================================
+// Rate Limit Config View Tests
+// ============================================================================
+
+#[test]
+fn test_rate_limit_config_returns_none_when_unset() {
+    let TestSetup { client, .. } = setup();
+
+    assert_eq!(client.rate_limit_config(&Direction::Outbound, &999u32), None);
+    assert_eq!(client.rate_limit_config(&Direction::Inbound, &888u32), None);
+}
+
+#[test]
+fn test_rate_limit_config_returns_config_when_set() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 42u32;
+
+    let cfg = config(500, 60);
+    client.set_rate_limit(&direction, &eid, &Some(cfg.clone()));
+
+    let result = client.rate_limit_config(&direction, &eid);
+    assert_eq!(result, Some(cfg));
+}
+
+#[test]
+fn test_rate_limit_config_returns_none_after_removal() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Inbound;
+    let eid = 77u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 10)));
+    assert!(client.rate_limit_config(&direction, &eid).is_some());
+
+    client.set_rate_limit(&direction, &eid, &None);
+    assert_eq!(client.rate_limit_config(&direction, &eid), None);
+}
+
+// ============================================================================
+// Direction Independence Tests
+// ============================================================================
+
+#[test]
+fn test_inbound_outbound_are_independent() {
+    let TestSetup { client, .. } = setup();
+    let eid = 10u32;
+
+    // Set different configs for inbound and outbound
+    client.set_rate_limit(&Direction::Inbound, &eid, &Some(config(100, 10)));
+    client.set_rate_limit(&Direction::Outbound, &eid, &Some(config(200, 20)));
+
+    assert_eq!(client.rate_limit_config(&Direction::Inbound, &eid), Some(config(100, 10)));
+    assert_eq!(client.rate_limit_config(&Direction::Outbound, &eid), Some(config(200, 20)));
+
+    // Consume from one direction doesn't affect the other
+    client.consume(&Direction::Inbound, &eid, &50i128);
+    assert_eq!(client.rate_limit_in_flight(&Direction::Inbound, &eid), 50);
+    assert_eq!(client.rate_limit_in_flight(&Direction::Outbound, &eid), 0);
+}
+
+#[test]
+fn test_different_eids_are_independent() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+
+    client.set_rate_limit(&direction, &1u32, &Some(config(100, 10)));
+    client.set_rate_limit(&direction, &2u32, &Some(config(200, 20)));
+
+    client.consume(&direction, &1u32, &50i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &1u32), 50);
+    assert_eq!(client.rate_limit_in_flight(&direction, &2u32), 0);
+}
+
+// ============================================================================
+// Edge Case Tests
+// ============================================================================
+
+#[test]
+fn test_consume_zero_amount_succeeds() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 100)));
+
+    // Consuming zero should succeed
+    client.consume(&direction, &eid, &0i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 0);
+}
+
+#[test]
+fn test_release_zero_amount_succeeds() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 100)));
+    client.consume(&direction, &eid, &50i128);
+
+    // Releasing zero should succeed
+    client.release(&direction, &eid, &0i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 50);
+}
+
+#[test]
+fn test_consume_exact_capacity() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 100)));
+
+    // Consuming exact capacity should succeed
+    client.consume(&direction, &eid, &100i128);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 100);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 0);
+}
+
+#[test]
+fn test_decay_fully_restores_capacity() {
+    let TestSetup { env, client } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    env.ledger().set_timestamp(1_000);
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 10)));
+
+    client.consume(&direction, &eid, &100i128);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 0);
+
+    // Advance full window => full decay
+    env.ledger().set_timestamp(1_010);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 0);
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 100);
+}
+
+#[test]
+fn test_decay_beyond_window_clamps_to_zero() {
+    let TestSetup { env, client } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    env.ledger().set_timestamp(1_000);
+    client.set_rate_limit(&direction, &eid, &Some(config(100, 10)));
+
+    client.consume(&direction, &eid, &50i128);
+
+    // Advance way beyond window
+    env.ledger().set_timestamp(2_000);
+    assert_eq!(client.rate_limit_in_flight(&direction, &eid), 0);
+}
+
+#[test]
+fn test_limit_zero_blocks_all_consumption() {
+    let TestSetup { client, .. } = setup();
+    let direction = Direction::Outbound;
+    let eid = 1u32;
+
+    // Set limit to 0 (valid config)
+    client.set_rate_limit(&direction, &eid, &Some(config(0, 10)));
+    assert_eq!(client.rate_limit_capacity(&direction, &eid), 0);
+
+    // Any non-zero consumption should fail
+    let res = client.try_consume(&direction, &eid, &1i128);
+    assert_eq!(res.err().unwrap().ok().unwrap(), RateLimitError::ExceededRateLimit.into());
+
+    // Zero consumption should still succeed
+    client.consume(&direction, &eid, &0i128);
+}

package/contracts/oapps/oft/src/tests/mod.rs

@@ -0,0 +1,2 @@
+mod extensions;
+mod oft_types;

package/contracts/oapps/oft/src/tests/oft_types/lock_unlock.rs

@@ -0,0 +1,180 @@
+extern crate std;
+
+use crate::oft_types::lock_unlock;
+use endpoint_v2::Origin;
+use oapp::oapp_receiver::{LzReceiveInternal, OAppReceiver};
+use oft_core::{types::OFTReceipt, OFTCore, OFTInternal};
+use soroban_sdk::{
+    contract, contractimpl, contracttype,
+    testutils::Address as _,
+    token::{StellarAssetClient, TokenClient},
+    Address, Bytes, BytesN, Env,
+};
+
+// ============================================================================
+// Mock Contracts
+// ============================================================================
+
+#[contract]
+struct DummyEndpoint;
+
+#[derive(Clone)]
+#[contracttype]
+enum DummyEndpointDataKey {
+    Delegate(Address),
+}
+
+#[contractimpl]
+impl DummyEndpoint {
+    pub fn set_delegate(env: Env, oapp: &Address, delegate: &Option<Address>) {
+        let key = DummyEndpointDataKey::Delegate(oapp.clone());
+        match delegate {
+            Some(d) => env.storage().persistent().set(&key, d),
+            None => env.storage().persistent().remove(&key),
+        }
+    }
+}
+
+// ============================================================================
+// LockUnlock OFT Harness Contract
+// ============================================================================
+
+#[oapp_macros::oapp(custom = [receiver])]
+pub struct LockUnlockHarnessOFT;
+
+#[contractimpl]
+impl LockUnlockHarnessOFT {
+    pub fn __constructor(
+        env: &Env,
+        token: &Address,
+        owner: &Address,
+        endpoint: &Address,
+        delegate: &Option<Address>,
+        shared_decimals: u32,
+    ) {
+        Self::__initialize_oft(env, owner, token, endpoint, delegate, shared_decimals);
+    }
+
+    pub fn debit(env: Env, sender: Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        <Self as OFTInternal>::__debit(&env, &sender, amount_ld, min_amount_ld, dst_eid)
+    }
+
+    pub fn credit(env: Env, to: Address, amount_ld: i128, src_eid: u32) -> i128 {
+        <Self as OFTInternal>::__credit(&env, &to, amount_ld, src_eid)
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OFTCore for LockUnlockHarnessOFT {}
+
+impl LzReceiveInternal for LockUnlockHarnessOFT {
+    fn __lz_receive(
+        env: &Env,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        extra_data: &Bytes,
+        executor: &Address,
+        value: i128,
+    ) {
+        <Self as OFTInternal>::__receive(env, origin, guid, message, extra_data, executor, value)
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OAppReceiver for LockUnlockHarnessOFT {}
+
+impl OFTInternal for LockUnlockHarnessOFT {
+    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        lock_unlock::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
+    }
+
+    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
+        lock_unlock::credit::<Self>(env, to, amount_ld, src_eid)
+    }
+}
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+struct TestSetup {
+    env: Env,
+    client: LockUnlockHarnessOFTClient<'static>,
+    oft_address: Address,
+    token: Address,
+}
+
+fn setup() -> TestSetup {
+    let env = Env::default();
+    // Enable mock_all_auths_allowing_non_root_auth for all tests to bypass authorization checks
+    // including sub-contract invocations like token transfers
+    env.mock_all_auths_allowing_non_root_auth();
+
+    let token_admin = Address::generate(&env);
+    let sac = env.register_stellar_asset_contract_v2(token_admin.clone());
+    let token = sac.address();
+    let endpoint = env.register(DummyEndpoint, ());
+
+    let owner = Address::generate(&env);
+    let delegate: Option<Address> = None;
+    let shared_decimals: u32 = 6;
+
+    let oft_address = env.register(LockUnlockHarnessOFT, (&token, &owner, &endpoint, &delegate, &shared_decimals));
+    let client = LockUnlockHarnessOFTClient::new(&env, &oft_address);
+
+    TestSetup { env, client, oft_address, token }
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+#[test]
+fn test_debit_transfers_to_contract() {
+    let TestSetup { env, client, oft_address, token, .. } = setup();
+
+    let sender = Address::generate(&env);
+
+    // Auth is automatically mocked by mock_all_auths_allowing_non_root_auth
+    StellarAssetClient::new(&env, &token).mint(&sender, &1_000_000i128);
+
+    let token_client = TokenClient::new(&env, &token);
+    let sender_before = token_client.balance(&sender);
+    let contract_before = token_client.balance(&oft_address);
+
+    // With shared_decimals=6 and typical SAC decimals=7, conversion_rate=10 => 105 -> 100.
+    // debit transfers from sender to OFT contract
+    let amount_ld = 105i128;
+
+    let receipt = client.debit(&sender, &amount_ld, &0i128, &999u32);
+    assert_eq!(receipt.amount_sent_ld, receipt.amount_received_ld);
+
+    // LockUnlock transfers `amount_received_ld` from sender -> contract.
+    assert_eq!(token_client.balance(&sender), sender_before - receipt.amount_received_ld);
+    assert_eq!(token_client.balance(&oft_address), contract_before + receipt.amount_received_ld);
+}
+
+#[test]
+fn test_credit_transfers_from_contract() {
+    let TestSetup { env, client, oft_address, token, .. } = setup();
+
+    let recipient = Address::generate(&env);
+
+    // Auth is automatically mocked by mock_all_auths_allowing_non_root_auth
+    StellarAssetClient::new(&env, &token).mint(&oft_address, &1_000_000i128);
+
+    let token_client = TokenClient::new(&env, &token);
+    let contract_before = token_client.balance(&oft_address);
+    let recipient_before = token_client.balance(&recipient);
+
+    // credit transfers from OFT contract to recipient
+    let amount = 123i128;
+
+    let credited = client.credit(&recipient, &amount, &1u32);
+    assert_eq!(credited, amount);
+
+    // LockUnlock transfers `amount` from contract -> recipient.
+    assert_eq!(token_client.balance(&oft_address), contract_before - amount);
+    assert_eq!(token_client.balance(&recipient), recipient_before + amount);
+}

package/contracts/oapps/oft/src/tests/oft_types/mod.rs

@@ -0,0 +1 @@
+mod lock_unlock;

package/contracts/oapps/oft-core/integration-tests/setup.rs

@@ -172,7 +172,8 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let oft_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let oft_token = oft_sac.address();
 
-    let endpoint_address = env.register(EndpointV2, (&owner,));
+    let eid: u32 = 30400; // Test EID
+    let endpoint_address = env.register(EndpointV2, (&owner, eid, &native_token));
     let fee_recipient = Address::generate(env);
     let sml_address = env.register(SimpleMessageLib, (&owner, &endpoint_address, &fee_recipient));
     let delegate: Option<Address> = Some(owner.clone());
@@ -198,8 +199,6 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     endpoint.set_zro(&zro_token);
 
     register_library(env, &owner, &endpoint, &sml.address);
-
-    let eid = endpoint.eid();
     ChainSetup { eid, owner, native_token, oft_token, endpoint, sml, oft, composer }
 }
 

package/contracts/oapps/oft-core/src/lib.rs

@@ -12,7 +12,7 @@ pub use oft_core::*;
 
 #[cfg(test)]
 #[path = "../integration-tests/mod.rs"]
-pub mod integration_tests;
+mod integration_tests;
 
 #[cfg(test)]
-pub mod tests;
+mod tests;

package/contracts/oapps/oft-core/src/tests/mod.rs

@@ -6,7 +6,7 @@ pub mod test_oft_msg_codec;
 pub mod test_decimals;
 pub mod test_lz_receive;
 pub mod test_msg_inspector;
-pub mod test_oft_version;
+pub mod test_oft_version_and_approval;
 pub mod test_quote_oft;
 pub mod test_quote_send;
 pub mod test_resolve_address;

package/contracts/oapps/oft-core/src/tests/{test_oft_version.rs → test_oft_version_and_approval.rs}

@@ -11,3 +11,12 @@ fn test_oft_version_returns_correct_values() {
     assert_eq!(major, 1);
     assert_eq!(minor, 1);
 }
+
+#[test]
+fn test_approval_required_returns_false_by_default() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Default OFTCore behavior: no separate token approval is required.
+    assert!(!setup.oft.approval_required());
+}