@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

package/contracts/ERROR_SPEC.md

@@ -1,44 +0,0 @@
-# Stellar LayerZero Protocol - Error Code Specification
-
-This document defines the error code allocation strategy for the Stellar LayerZero contracts.
-
-## Purpose
-
-Each library has a unique error code range to:
-
-- **Prevent collisions**: Avoid error code conflicts between different libraries
-- **Enable traceability**: Quickly identify which library an error originated from based on its code
-- **Simplify debugging**: Error codes are globally unique, making it easier to track and diagnose issues
-
-## Allocation Rules
-
-- **Library allocation**: Each library is allocated a 100-unit block (e.g., 1000-1099, 1100-1199). Total errors in one library should not exceed 100.
-- **Sub-range allocation**: Each error type within a library is allocated a 10-unit block. Example from `utils` (1000-1099):
-
-    - BufferReaderError: 1000-1009
-    - BufferWriterError: 1010-1019
-    - TtlConfigurableError: 1020-1029
-    - OwnableError: 1030-1039
-    - BytesExtError: 1040-1049
-    - UpgradeableError: 1050-1059
-    - MultisigError: 1060-1069
-
-    If an error type exceeds 10 errors (e.g., 12 errors), it extends into the next block but the following error type should start at the next 10-unit boundary (e.g., if errors are 1000-1011, next sub-range starts at 1020).
-
-- **Auto-increment**: Within each error enum, values auto-increment from the starting value.
-
-## Error Code Ranges
-
-| Range       | Category        | Library            | Description                                                  |
-| ----------- | --------------- | ------------------ | ------------------------------------------------------------ |
-| 1 - 999     | Contract Errors | -                  | Application-specific contract errors (auto-increment from 1) |
-| 1000 - 1099 | Protocol Lib    | utils              | `utils/src/errors.rs`                                        |
-| 1100 - 1199 | Protocol Lib    | message-lib-common | `message-libs/message-lib-common/src/errors.rs`              |
-| 1200 - 1299 | Protocol Lib    | worker             | `workers/worker/src/errors.rs`                               |
-| 1300 - 1999 | Protocol Lib    | (reserved)         | Future protocol libs                                         |
-| 2000 - 2099 | OApp Lib        | oapp               | `oapps/oapp/src/errors.rs`                                   |
-| 2100 - 2999 | OApp Lib        | (reserved)         | Future OApp libs                                             |
-| 3000 - 3099 | OFT Lib         | oft-core           | `oapps/oft-core/src/errors.rs`                               |
-| 3100 - 3999 | OFT Lib         | (reserved)         | Future OFT libs                                              |
-
----

package/contracts/endpoint-v2/ARCHITECTURE.md

@@ -1,233 +0,0 @@
-# EndpointV2 Architecture
-
-## Overview
-
-**EndpointV2** is the core Soroban contract for LayerZero's cross-chain messaging protocol on Stellar. It serves as the central hub for omnichain applications (OApps) to send and receive cross-chain messages using pluggable message libraries.
-
-**Key Architecture Principles:**
-
-- **Interfaces exported as library** - External contracts depend on trait definitions only
-- **Contract entry point** - `endpoint_v2.rs` implements all interfaces
-- **Internal modules** - Separate files for business logic implementation
-- **Centralized resources** - Unified `storage.rs`, `errors.rs`, `events.rs`
-
----
-
-## Project Structure
-
-```
-endpoint-v2/
-├── Cargo.toml                      # Package configuration with "library" feature
-├── ARCHITECTURE.md                 # This file - architecture documentation
-│
-├── src/
-
-│   ├── interfaces/                 # Public interface definitions (library exports)
-│   │   ├── mod.rs
-│   │   ├── layerzero_endpoint_v2.rs      # Core endpoint interface
-│   │   ├── layerzero_composer.rs         # Interface for Composer
-│   │   ├── layerzero_receiver.rs         # Interface for OApp (receive)
-│   │   ├── message_lib.rs                # Interface for MessageLib
-│   │   ├── message_lib_manager.rs        # Library management interface of EndpointV2
-│   │   ├── send_lib.rs                   # Interface for SendLib (extends MessageLib)
-│   │   ├── messaging_channel.rs          # Channel operations interface of EndpointV2
-│   │   └── messaging_composer.rs         # Compose operations interface of EndpointV2
-|   |
-│   ├── lib.rs                      # Module exports & conditional compilation
-│   ├── endpoint_v2.rs              # Main contract implementation
-│   ├── message_lib_manager.rs      # Internal: Library registration & management
-│   ├── messaging_channel.rs        # Internal: Channel logic (nonce, payload)
-│   ├── messaging_composer.rs       # Internal: Compose queue management
-│   │
-│   ├── util.rs                     # Public: Utility functions (GUID, payload, keccak256)
-│   ├── storage.rs                  # Centralized storage management
-│   ├── errors.rs                   # Centralized error definitions
-│   ├── events.rs                   # Centralized event definitions
-│   │
-│   └── tests/                      # Comprehensive test suite
-
-```
-
----
-
-## Design Principles
-
-### 1. Interfaces as Library Exports
-
-The `interfaces/` directory contains Soroban trait definitions exported as a library for external contracts. Controlled by the `library` feature in `Cargo.toml`.
-
-```rust
-// lib.rs - conditional compilation
-cfg_if::cfg_if! {
-    if #[cfg(any(not(feature = "library"), feature = "default"))] {
-        mod endpoint_v2;  // Only included when building contract
-        mod errors;
-        mod events;
-        mod storage;
-
-        pub use endpoint_v2::{EndpointV2, EndpointV2Client};
-    }
-}
-```
-
-**Usage Example:**
-
-```rust
-// In a MessageLib contract
-use endpoint_v2::{EndpointV2Client, OutboundPacket};
-
-let endpoint = EndpointV2Client::new(&env, &endpoint_address);
-endpoint.verify(&origin, &receiver, &payload_hash);
-```
-
-**Interface Categories:**
-
-- **For OApps**: `ILayerZeroReceiver`, `ILayerZeroComposer`
-- **For MessageLibs**: `IMessageLib`, `ISendLib` (includes `OutboundPacket`, `FeeRecipient`)
-- **For All**: `ILayerZeroEndpointV2` (composes all sub-interfaces)
-- **Utilities**: `util::compute_guid()`, `util::build_payload()`, `util::keccak256()`
-
-### 2. Contract Entry Point (`endpoint_v2.rs`)
-
-The main Soroban contract that implements all interfaces and delegates to internal modules:
-
-```rust
-#[contract]
-pub struct EndpointV2;
-
-#[contract_impl]
-impl EndpointV2 {
-    pub fn __constructor(env: &Env, eid: u32, native_token: &Address, owner: &Address) {
-        storage::EndpointData::set_eid(env, eid);
-        storage::EndpointData::set_native_token(env, native_token);
-        ownable::set_owner(env, owner);
-    }
-
-    pub fn set_ttl_configs(env: &Env, ...) {
-        ownable::require_owner_auth(env);
-        // Configure TTL settings for storage
-    }
-}
-
-#[contract_impl]
-impl ILayerZeroEndpointV2 for EndpointV2 {
-    fn send(env: &Env, sender: &Address, params: &MessagingParams, ...) -> MessagingReceipt {
-        sender.require_auth();
-        // Send cross-chain message via SendLib
-    }
-
-    fn lz_receive(env: &Env, origin: &Origin, receiver: &Address, ...) {
-        // Verify payload hash and deliver to OApp
-        let receiver_client = LayerZeroReceiverClient::new(env, receiver);
-        receiver_client.lz_receive(...);
-    }
-}
-
-#[contract_impl]
-impl Ownable for EndpointV2 {
-    // Ownership management
-}
-```
-
-**Implements:** `ILayerZeroEndpointV2` (which includes `IMessageLibManager`, `IMessagingChannel`, `IMessagingComposer`), `Ownable`
-
-### 3. Internal Implementation Modules
-
-Internal modules provide business logic implementation for `endpoint_v2.rs`:
-
-| Module                       | Purpose                                                                                                  |
-| ---------------------------- | -------------------------------------------------------------------------------------------------------- |
-| **`message_lib_manager.rs`** | Library registration, selection, and configuration. Tracks default/per-OApp libraries per EID.           |
-| **`messaging_channel.rs`**   | Nonce tracking, payload hash storage/verification, message state transitions (verify → receive → clear). |
-| **`messaging_composer.rs`**  | Manages compose message queues for multi-stage execution between OApp and Composers.                     |
-| **`util.rs`**                | Public utilities: `compute_guid()`, `build_payload()`, `keccak256()` for message processing.             |
-
-### 4. Centralized Resource Management
-
-| Module           | Purpose                                                                                                                                                     | Example                                                                                          |
-| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
-| **`storage.rs`** | Type-safe storage with `#[storage]` derive macro. Organized into: `EndpointData`, `MessagingChannelData`, `MessageLibManagerData`, `MessagingComposerData`. | `EndpointData::eid(env)`, `MessagingChannelData::outbound_nonce(env, sender, dst_eid, receiver)` |
-| **`errors.rs`**  | All error codes using `#[contracterror]`. 29 error types including validation, authorization, state, and configuration errors.                              | `InvalidNonce = 3`, `Unauthorized = 10`, `InsufficientNativeFee = 27`                            |
-| **`events.rs`**  | All events using `#[contractevent]`. Includes config, messaging, library, and compose events.                                                               | `PacketSent`, `PacketVerified`, `LibraryRegistered`                                              |
-
----
-
-## Key Patterns
-
-**1. Interface Composition**
-
-```rust
-pub trait ILayerZeroEndpointV2:
-    IMessageLibManager + IMessagingChannel + IMessagingComposer
-{
-    fn quote(env: &Env, sender: &Address, params: &MessagingParams) -> MessagingFee;
-    fn send(env: &Env, sender: &Address, params: &MessagingParams, refund_address: &Address) -> MessagingReceipt;
-    fn lz_receive(env: &Env, origin: &Origin, receiver: &Address, guid: &BytesN<32>, message: &Bytes, extra_data: &Bytes);
-    // ... more methods
-}
-```
-
-Each sub-interface handles one domain, enabling modularity and clear separation of concerns. Ownership is handled through the `Ownable` trait from the `utils` crate.
-
-**2. Client Generation**
-
-```rust
-#[contractclient(name = "LayerZeroReceiverClient")]
-pub trait ILayerZeroReceiver {
-    fn lz_receive(env: &Env, origin: &Origin, guid: &BytesN<32>, message: &Bytes, extra_data: &Bytes);
-}
-
-// Usage: type-safe cross-contract calls
-let receiver = LayerZeroReceiverClient::new(&env, &receiver_address);
-receiver.lz_receive(&origin, &guid, &message, &extra_data);
-```
-
-The `#[contractclient]` macro automatically generates type-safe client wrappers for cross-contract calls.
-
----
-
-## Message Flows
-
-### Sending
-
-```
-OApp → EndpointV2.send(sender, params, refund_address)
-    ↓
-    MessageLibManager.get_send_library(sender, dst_eid)
-    ↓
-    MessagingChannel.outbound_nonce++ (create OutboundPacket)
-    ↓
-    SendLib.send(packet, options, pay_in_zro) → Returns (Vec<FeeRecipient>, encoded_packet)
-    ↓
-    Pay fees (native or ZRO) to fee recipients
-    ↓
-    Emit PacketSent event
-    ↓
-    Return MessagingReceipt { guid, nonce, fee }
-```
-
-### Receiving
-
-```
-Off-chain Verifier → EndpointV2.verify(origin, receiver, payload_hash)
-    ↓
-    Validate library is registered receive lib
-    ↓
-    MessagingChannel.inbound(receiver, origin, payload_hash) → Store payload hash
-    ↓
-    Emit PacketVerified event
-
-Later: Executor → OApp.lz_receive(origin, guid, message, extra_data)
-    ↓
-    OApp executes business logic
-    ↓
-    OApp → EndpointV2.clear(caller, origin, receiver, guid, message)
-    ↓
-    Validate caller is OApp or its delegate (require_oapp_auth)
-    ↓
-    Validate payload hash matches keccak256(guid || message)
-    ↓
-    Clear payload hash from storage
-    ↓
-    Emit PacketDelivered event
-```

package/contracts/oapps/oapp/src/tests/test_oapp_core.rs

@@ -1,175 +0,0 @@
-use crate::{self as oapp, oapp_core::PeerSet, oapp_receiver::LzReceiveInternal};
-use endpoint_v2::Origin;
-use soroban_sdk::{
-    contract, contractimpl,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Bytes, BytesN, Env, IntoVal,
-};
-use utils::testing_utils::assert_event;
-
-#[contract]
-pub struct DummyEndpoint;
-
-#[contractimpl]
-impl DummyEndpoint {
-    pub fn set_delegate(_env: Env, _oapp: &Address, _delegate: &Option<Address>) {
-        // do nothing
-    }
-}
-
-#[oapp_macros::oapp]
-pub struct DummyOApp;
-
-impl LzReceiveInternal for DummyOApp {
-    fn __lz_receive(
-        _env: &Env,
-        _origin: &Origin,
-        _guid: &BytesN<32>,
-        _message: &Bytes,
-        _extra_data: &Bytes,
-        _executor: &Address,
-        _value: i128,
-    ) {
-        // Not used in core tests
-    }
-}
-
-#[contractimpl]
-impl DummyOApp {
-    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
-        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, &None);
-    }
-}
-
-const REMOTE_EID: u32 = 100;
-const UNSET_EID: u32 = 999;
-
-struct TestSetup<'a> {
-    env: Env,
-    owner: Address,
-    endpoint: Address,
-    oapp_client: DummyOAppClient<'a>,
-}
-
-fn setup<'a>() -> TestSetup<'a> {
-    let env = Env::default();
-
-    let owner = Address::generate(&env);
-    soroban_sdk::log!(&env, "owner: {}", owner);
-    let endpoint = env.register(DummyEndpoint, ());
-    soroban_sdk::log!(&env, "endpoint: {}", endpoint);
-    let oapp = env.register(DummyOApp, (&owner, &endpoint));
-    soroban_sdk::log!(&env, "oapp: {}", oapp);
-    let oapp_client = DummyOAppClient::new(&env, &oapp);
-    TestSetup { env, owner, endpoint, oapp_client }
-}
-
-#[test]
-fn test_set_peer() {
-    let TestSetup { env, owner, oapp_client, .. } = setup();
-
-    let test_peer: BytesN<32> = BytesN::from_array(&env, &[33; 32]);
-    let test_peer_option = Some(test_peer.clone());
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &oapp_client.address,
-            fn_name: "set_peer",
-            args: (&REMOTE_EID, &test_peer_option).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    oapp_client.set_peer(&REMOTE_EID, &test_peer_option);
-
-    // assert event
-    assert_event(&env, &oapp_client.address, PeerSet { eid: REMOTE_EID, peer: Some(test_peer.clone()) });
-
-    // Test getting peer for set eid
-    let retrieved_peer = oapp_client.peer(&REMOTE_EID);
-    assert_eq!(Some(test_peer), retrieved_peer);
-
-    // Test getting peer for unset eid
-    let retrieved_peer = oapp_client.peer(&UNSET_EID);
-    assert_eq!(None, retrieved_peer);
-}
-
-#[test]
-#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
-fn test_set_peer_unauthorized() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    let test_peer: BytesN<32> = BytesN::from_array(&env, &[33; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(test_peer));
-}
-
-#[test]
-fn test_get_peer_success() {
-    let TestSetup { env, oapp_client, .. } = setup();
-    env.mock_all_auths();
-
-    let test_peer: BytesN<32> = BytesN::from_array(&env, &[1; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(test_peer.clone()));
-
-    let retrieved_peer = oapp_client.peer(&REMOTE_EID);
-    assert_eq!(Some(test_peer), retrieved_peer);
-}
-
-#[test]
-fn test_get_peer_returns_none_for_unset_eid() {
-    let TestSetup { oapp_client, .. } = setup();
-
-    let result = oapp_client.peer(&UNSET_EID);
-    assert_eq!(result, None);
-}
-
-#[test]
-fn test_update_peer() {
-    let TestSetup { env, oapp_client, .. } = setup();
-    env.mock_all_auths();
-
-    // Set initial peer
-    let initial_peer: BytesN<32> = BytesN::from_array(&env, &[1; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(initial_peer));
-
-    // Update to new peer
-    let updated_peer: BytesN<32> = BytesN::from_array(&env, &[2; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(updated_peer.clone()));
-
-    let retrieved_peer = oapp_client.peer(&REMOTE_EID);
-    assert_eq!(Some(updated_peer), retrieved_peer);
-}
-
-#[test]
-fn test_set_delegate() {
-    let TestSetup { env, owner, oapp_client, .. } = setup();
-
-    let delegate = Address::generate(&env);
-    let delegate_option = Some(delegate.clone());
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &oapp_client.address,
-            fn_name: "set_delegate",
-            args: (&delegate_option,).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    oapp_client.set_delegate(&delegate_option);
-}
-
-#[test]
-#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
-fn test_set_delegate_unauthorized() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    let delegate = Address::generate(&env);
-    oapp_client.set_delegate(&Some(delegate));
-}
-
-#[test]
-fn test_get_endpoint() {
-    let TestSetup { endpoint, oapp_client, .. } = setup();
-
-    let retrieved_endpoint = oapp_client.endpoint();
-    assert_eq!(endpoint, retrieved_endpoint);
-}

package/contracts/oapps/oapp/src/tests/test_oapp_options_type3.rs

@@ -1,212 +0,0 @@
-use crate::{
-    self as oapp,
-    oapp_core::OAppCore,
-    oapp_options_type3::{EnforcedOptionParam, EnforcedOptionSet},
-    oapp_receiver::{LzReceiveInternal, OAppReceiver},
-};
-use common_macros::contract_impl;
-use endpoint_v2::Origin;
-use soroban_sdk::{
-    contract, contractimpl,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    vec, Address, Bytes, BytesN, Env, IntoVal,
-};
-use utils::testing_utils::assert_event;
-
-const OPTION_TYPE_3: u32 = 3;
-const REMOTE_EID_1: u32 = 100;
-const REMOTE_EID_2: u32 = 200;
-const MSG_TYPE_SEND: u32 = 1;
-const MSG_TYPE_RECEIVE: u32 = 2;
-
-#[contract]
-pub struct DummyEndpoint;
-
-#[contractimpl]
-impl DummyEndpoint {
-    pub fn set_delegate(_env: Env, _oapp: &Address, _delegate: &Option<Address>) {
-        // do nothing
-    }
-}
-
-#[oapp_macros::oapp(custom = [core, sender, receiver])]
-pub struct DummyOAppOptionsType3;
-
-#[contract_impl(contracttrait)]
-impl OAppCore for DummyOAppOptionsType3 {}
-
-impl LzReceiveInternal for DummyOAppOptionsType3 {
-    fn __lz_receive(
-        _env: &Env,
-        _origin: &endpoint_v2::Origin,
-        _guid: &BytesN<32>,
-        _message: &Bytes,
-        _extra_data: &Bytes,
-        _executor: &Address,
-        _value: i128,
-    ) {
-        // Dummy implementation for testing
-    }
-}
-
-#[contract_impl(contracttrait)]
-impl OAppReceiver for DummyOAppOptionsType3 {}
-
-#[contract_impl]
-impl DummyOAppOptionsType3 {
-    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
-        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, delegate);
-    }
-}
-
-struct TestSetup<'a> {
-    env: Env,
-    owner: Address,
-    oapp_client: DummyOAppOptionsType3Client<'a>,
-}
-
-fn setup<'a>() -> TestSetup<'a> {
-    let env = Env::default();
-
-    let owner = Address::generate(&env);
-    let endpoint = env.register(DummyEndpoint, ());
-    let delegate: Option<Address> = Some(owner.clone());
-    let oapp = env.register(DummyOAppOptionsType3, (&owner, &endpoint, &delegate));
-    let oapp_client = DummyOAppOptionsType3Client::new(&env, &oapp);
-
-    TestSetup { env, owner, oapp_client }
-}
-
-fn create_valid_options(env: &Env, data: &[u8]) -> Bytes {
-    let mut buffer = Bytes::from_array(env, &(OPTION_TYPE_3 as u16).to_be_bytes());
-    buffer.extend_from_slice(data);
-    buffer
-}
-
-#[test]
-fn test_set_and_get_enforced_options() {
-    let TestSetup { env, owner, oapp_client, .. } = setup();
-
-    // Create enforced options for different eid/msg_type combinations
-    let options1 = create_valid_options(&env, &[1, 2, 3, 4]);
-    let options2 = create_valid_options(&env, &[5, 6, 7, 8]);
-
-    let enforced_params = vec![
-        &env,
-        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: options1.clone() },
-        EnforcedOptionParam { eid: REMOTE_EID_2, msg_type: MSG_TYPE_RECEIVE, options: options2.clone() },
-    ];
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &oapp_client.address,
-            fn_name: "set_enforced_options",
-            args: (&enforced_params,).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    oapp_client.set_enforced_options(&enforced_params);
-
-    // assert events
-    assert_event(&env, &oapp_client.address, EnforcedOptionSet { enforced_option_params: enforced_params.clone() });
-
-    // Verify options were set correctly
-    let retrieved1 = oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND);
-    assert_eq!(retrieved1, options1);
-
-    let retrieved2 = oapp_client.enforced_options(&REMOTE_EID_2, &MSG_TYPE_RECEIVE);
-    assert_eq!(retrieved2, options2);
-}
-
-#[test]
-#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
-fn test_set_enforced_options_unauthorized() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    let options = create_valid_options(&env, &[1, 2, 3, 4]);
-    let enforced_params =
-        vec![&env, EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: options.clone() }];
-    oapp_client.set_enforced_options(&enforced_params);
-}
-
-#[test]
-fn test_combine_options_with_empty_enforced() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    let extra_options = create_valid_options(&env, &[9, 10, 11]);
-    // When no enforced options are set, should return extra options
-    let combined = oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra_options);
-    assert_eq!(combined, extra_options);
-}
-
-#[test]
-fn test_combine_options_with_empty_extra() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    // This test now simply validates that empty extra options return empty result
-    // when no enforced options are set
-    let empty_extra = Bytes::new(&env);
-    let combined = oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &empty_extra);
-    assert_eq!(combined, empty_extra);
-}
-
-#[test]
-fn test_combine_options_both_present() {
-    let TestSetup { env, oapp_client, .. } = setup();
-    env.mock_all_auths();
-
-    let enforced = create_valid_options(&env, &[1, 2, 3]);
-    oapp_client.set_enforced_options(&vec![
-        &env,
-        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: enforced.clone() },
-    ]);
-
-    let extra = create_valid_options(&env, &[4, 5, 6]);
-    let combined = oapp_client.combine_options(&REMOTE_EID_1, &MSG_TYPE_SEND, &extra);
-
-    let mut expected_combined = enforced;
-    expected_combined.append(&extra.slice(2..));
-
-    // Should return extra options when no enforced options exist
-    assert_eq!(combined, expected_combined);
-}
-
-#[test]
-fn test_update_enforced_options() {
-    let TestSetup { env, oapp_client, .. } = setup();
-    env.mock_all_auths();
-
-    // Set initial options
-    let initial_options = create_valid_options(&env, &[1, 2, 3]);
-    let params = vec![
-        &env,
-        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: initial_options.clone() },
-    ];
-    oapp_client.set_enforced_options(&params);
-
-    // Verify initial options
-    let retrieved = oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND);
-    assert_eq!(retrieved, initial_options);
-
-    // Update with new options
-    let updated_options = create_valid_options(&env, &[9, 8, 7, 6, 5]);
-    let update_params = vec![
-        &env,
-        EnforcedOptionParam { eid: REMOTE_EID_1, msg_type: MSG_TYPE_SEND, options: updated_options.clone() },
-    ];
-    oapp_client.set_enforced_options(&update_params);
-
-    // Verify options were updated
-    let retrieved_after_update = oapp_client.enforced_options(&REMOTE_EID_1, &MSG_TYPE_SEND);
-    assert_eq!(retrieved_after_update, updated_options);
-}
-
-#[test]
-fn test_get_enforced_options_for_unset_combination() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    // Try to get options for an eid/msg_type that hasn't been set
-    let result = oapp_client.enforced_options(&999, &999);
-    assert_eq!(result, Bytes::new(&env));
-}