@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.123

package/contracts/oapps/counter/src/storage.rs

@@ -1,32 +0,0 @@
-use common_macros::storage;
-use soroban_sdk::BytesN;
-
-#[storage]
-pub enum CounterStorage {
-    #[instance(u32)]
-    EID,
-
-    #[persistent(u64)]
-    #[default(0)]
-    MaxReceivedNonce { eid: u32, sender: BytesN<32> }, // (eid, sender) => nonce
-
-    #[instance(bool)]
-    #[default(false)]
-    OrderedNonce,
-
-    #[instance(u64)]
-    #[default(0)]
-    Count,
-
-    #[instance(u64)]
-    #[default(0)]
-    ComposedCount,
-
-    #[persistent(u64)]
-    #[default(0)]
-    InboundCount { eid: u32 },
-
-    #[persistent(u64)]
-    #[default(0)]
-    OutboundCount { eid: u32 },
-}

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

@@ -1,24 +0,0 @@
-use soroban_sdk::{
-    testutils::{MockAuth, MockAuthInvoke},
-    token::StellarAssetClient,
-    Address, Env, IntoVal,
-};
-
-pub mod test_codec;
-pub mod test_counter;
-pub mod test_u256_ext;
-
-pub fn mint_to(env: &Env, owner: &Address, native_token: &Address, to: &Address, amount: i128) {
-    env.mock_auths(&[MockAuth {
-        address: owner,
-        invoke: &MockAuthInvoke {
-            contract: native_token,
-            fn_name: "mint",
-            args: (to, amount).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    let sac = StellarAssetClient::new(env, native_token);
-    sac.mint(to, &amount);
-}

package/contracts/oapps/counter/src/tests/test_codec.rs

@@ -1,64 +0,0 @@
-use crate::codec::*;
-use soroban_sdk::{Bytes, Env};
-
-#[test]
-fn test_encode_and_decode() {
-    let env = Env::default();
-    let _msg_type = 1;
-    let _src_eid = 1;
-    let data = encode(&env, _msg_type.into(), _src_eid);
-    assert_eq!(msg_type(&data), MsgType::from(_msg_type));
-    assert_eq!(src_eid(&data), _src_eid);
-}
-
-#[test]
-fn test_encode_and_decode_with_value() {
-    let env = Env::default();
-    let _msg_type = 1;
-    let _src_eid = 1;
-    let _value = 100u32;
-    let data = encode_with_value(&env, _msg_type.into(), _src_eid, _value);
-    assert_eq!(msg_type(&data), MsgType::from(_msg_type));
-    assert_eq!(src_eid(&data), _src_eid);
-    assert_eq!(value(&env, &data), _value as i128);
-}
-
-#[test]
-fn test_msg_type() {
-    let env = Env::default();
-    let _msg_type = 1;
-    let data = encode(&env, _msg_type.into(), 1);
-    assert_eq!(msg_type(&data), MsgType::from(_msg_type));
-}
-
-#[test]
-fn test_zero_value_when_not_provided() {
-    let env = Env::default();
-    let data = encode(&env, 1.into(), 1);
-    assert_eq!(value(&env, &data), 0i128);
-}
-
-#[test]
-#[should_panic(expected = "cannot get msg type")]
-fn test_msg_type_panic_on_invalid_data() {
-    let env = Env::default();
-    let data = Bytes::new(&env);
-    msg_type(&data);
-}
-
-#[test]
-#[should_panic(expected = "object index out of bounds")]
-fn test_src_eid_panic_on_invalid_data() {
-    let env = Env::default();
-    let data = Bytes::new(&env);
-    src_eid(&data);
-}
-
-#[test]
-#[should_panic(expected = "expected fixed-length bytes slice, got slice with different size")]
-fn test_value_panic_on_short_value() {
-    let env = Env::default();
-    let mut data = encode(&env, 1.into(), 1);
-    data.extend_from_array(&[0u8; 3]);
-    value(&env, &data);
-}

package/contracts/oapps/counter/src/tests/test_counter.rs

@@ -1,387 +0,0 @@
-extern crate std;
-
-use endpoint_v2::{MessagingFee, MessagingParams, MessagingReceipt, Origin};
-use soroban_sdk::{
-    contract, contractimpl, log, symbol_short,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    Address, Bytes, BytesN, Env, IntoVal,
-};
-
-use crate::{
-    codec::{self, MsgType},
-    counter::{Counter, CounterClient},
-    errors::CounterError,
-    tests::mint_to,
-};
-
-struct TestSetup<'a> {
-    env: Env,
-    owner: Address,
-    counter: CounterClient<'a>,
-    endpoint: Address,
-    native_token: Address,
-}
-
-#[contract]
-pub struct DummyEndpoint;
-
-#[contractimpl]
-impl DummyEndpoint {
-    pub fn __constructor(env: Env, native_token: Address) {
-        env.storage().instance().set(&symbol_short!("ntk"), &native_token);
-    }
-
-    pub fn set_delegate(_env: Env, _oapp: Address, _delegate: Address) {
-        // do nothing
-    }
-
-    pub fn eid(_env: Env) -> u32 {
-        100
-    }
-
-    pub fn native_token(env: Env) -> Address {
-        env.storage().instance().get(&symbol_short!("ntk")).unwrap()
-    }
-
-    pub fn send(env: Env, _sender: Address, _params: MessagingParams, _refund_address: Address) -> MessagingReceipt {
-        MessagingReceipt {
-            guid: BytesN::from_array(&env, &[1u8; 32]),
-            nonce: 1,
-            fee: MessagingFee { native_fee: 100, zro_fee: 0 },
-        }
-    }
-
-    pub fn skip(_env: Env, _caller: Address, _receiver: Address, _src_eid: u32, _sender: BytesN<32>, _nonce: u64) {
-        // do nothing
-    }
-
-    pub fn clear(_env: Env, _caller: Address, _origin: Origin, _receiver: Address, _guid: BytesN<32>, _message: Bytes) {
-        // do nothing
-    }
-
-    pub fn clear_compose(
-        _env: Env,
-        _composer: Address,
-        _from: Address,
-        _guid: BytesN<32>,
-        _index: u32,
-        _message: Bytes,
-    ) {
-        // do nothing
-    }
-}
-
-fn setup<'a>() -> TestSetup<'a> {
-    let env = Env::default();
-    let owner = Address::generate(&env);
-    let sac = env.register_stellar_asset_contract_v2(owner.clone());
-
-    let endpoint = env.register(DummyEndpoint, (&sac.address(),));
-    let counter = env.register(Counter, (&owner, &endpoint, &owner));
-    let counter_client = CounterClient::new(&env, &counter);
-
-    log!(&env, "native_token: {}", sac.address());
-    log!(&env, "endpoint: {}", endpoint);
-    log!(&env, "counter: {}", counter);
-
-    TestSetup { env, owner, counter: counter_client, endpoint, native_token: sac.address() }
-}
-
-fn setup_mock_peer(env: &Env, owner: &Address, counter: &CounterClient<'_>, dst_eid: u32) -> BytesN<32> {
-    let peer = BytesN::from_array(env, &[1u8; 32]);
-    let peer_option = Some(peer.clone());
-    env.mock_auths(&[MockAuth {
-        address: owner,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "set_peer",
-            args: (&dst_eid, &peer_option, owner).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    counter.set_peer(&dst_eid, &peer_option, owner);
-    peer
-}
-
-fn set_ordered_nonce(env: &Env, owner: &Address, counter: &CounterClient<'_>, ordered_nonce: bool) {
-    env.mock_auths(&[MockAuth {
-        address: owner,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "set_ordered_nonce",
-            args: (&ordered_nonce,).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    counter.set_ordered_nonce(&ordered_nonce);
-}
-
-// tests for major entry functions
-
-#[test]
-fn test_increment() {
-    let TestSetup { env, owner, counter, endpoint, native_token, .. } = setup();
-
-    let sender = Address::generate(&env);
-    let dst_eid = 101;
-    let msg_type = MsgType::Vanilla;
-    let fee = MessagingFee { native_fee: 100, zro_fee: 0 };
-
-    setup_mock_peer(&env, &owner, &counter, dst_eid);
-    mint_to(&env, &owner, &native_token, &sender, fee.native_fee);
-
-    env.mock_auths(&[MockAuth {
-        address: &sender,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "increment",
-            args: (&sender, &dst_eid, &(msg_type as u32), &Bytes::new(&env), &fee).into_val(&env),
-            sub_invokes: &[MockAuthInvoke {
-                contract: &native_token,
-                fn_name: "transfer",
-                args: (&sender, &endpoint, &fee.native_fee).into_val(&env),
-                sub_invokes: &[],
-            }],
-        },
-    }]);
-    counter.increment(&sender, &dst_eid, &(msg_type as u32), &Bytes::new(&env), &fee);
-
-    assert_eq!(counter.outbound_count(&dst_eid), 1);
-}
-
-#[test]
-fn test_lz_receive_vanilla() {
-    let TestSetup { env, owner, counter, native_token, .. } = setup();
-
-    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
-    let guid = BytesN::from_array(&env, &[2u8; 32]);
-    let value = 100;
-    let message = codec::encode_with_value(&env, MsgType::Vanilla, origin.src_eid, value);
-    let executor = Address::generate(&env);
-    let extra_data = Bytes::new(&env);
-
-    setup_mock_peer(&env, &owner, &counter, origin.src_eid);
-
-    mint_to(&env, &owner, &native_token, &executor, value as i128);
-
-    let sub_invokes_with_transfer = MockAuthInvoke {
-        contract: &native_token,
-        fn_name: "transfer",
-        args: (&executor, &counter.address, &(value as i128)).into_val(&env),
-        sub_invokes: &[],
-    };
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "lz_receive",
-            args: (&executor, &origin, &guid, &message, &extra_data, &(value as i128)).into_val(&env),
-            sub_invokes: &[sub_invokes_with_transfer],
-        },
-    }]);
-
-    counter.lz_receive(&executor, &origin, &guid, &message, &extra_data, &(value as i128));
-
-    assert_eq!(counter.count(), 1);
-    assert_eq!(counter.inbound_count(&origin.src_eid), 1);
-}
-
-#[test]
-#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
-fn test_lz_receive_not_from_executor() {
-    let TestSetup { env, owner, counter, .. } = setup();
-
-    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
-    let guid = BytesN::from_array(&env, &[2u8; 32]);
-    let value = 100;
-    let message = codec::encode_with_value(&env, MsgType::Vanilla, origin.src_eid, value);
-    let executor = Address::generate(&env);
-    let extra_data = Bytes::new(&env);
-
-    setup_mock_peer(&env, &owner, &counter, origin.src_eid);
-    counter.lz_receive(&executor, &origin, &guid, &message, &extra_data, &(value as i128));
-}
-
-#[test]
-fn test_lz_receive_vanilla_ordered_nonce_wrong_nonce() {
-    let TestSetup { env, owner, counter, native_token, .. } = setup();
-
-    // next nonce should be 1 instead of 999
-    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 999 };
-    let guid = BytesN::from_array(&env, &[2u8; 32]);
-    let value = 100;
-    let message = codec::encode_with_value(&env, MsgType::Vanilla, origin.src_eid, value);
-    let executor = Address::generate(&env);
-    let extra_data = Bytes::new(&env);
-
-    setup_mock_peer(&env, &owner, &counter, origin.src_eid);
-    mint_to(&env, &owner, &native_token, &executor, value as i128);
-
-    let sub_invokes_with_transfer = MockAuthInvoke {
-        contract: &native_token,
-        fn_name: "transfer",
-        args: (&executor, &counter.address, &(value as i128)).into_val(&env),
-        sub_invokes: &[],
-    };
-    set_ordered_nonce(&env, &owner, &counter, true);
-
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "lz_receive",
-            args: (&executor, &origin, &guid, &message, &extra_data, &(value as i128)).into_val(&env),
-            sub_invokes: &[sub_invokes_with_transfer],
-        },
-    }]);
-
-    let result = counter.try_lz_receive(&executor, &origin, &guid, &message, &extra_data, &(value as i128));
-    assert_eq!(result.err().unwrap().ok().unwrap(), CounterError::OAppInvalidNonce.into());
-}
-
-#[test]
-fn test_lz_compose() {
-    let TestSetup { env, owner, counter, native_token, .. } = setup();
-
-    let from = Address::generate(&env);
-    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
-    let guid = BytesN::from_array(&env, &[2u8; 32]);
-    let value = 100;
-    let message = codec::encode_with_value(&env, MsgType::Composed, origin.src_eid, value);
-    let executor = Address::generate(&env);
-    let extra_data = Bytes::new(&env);
-
-    mint_to(&env, &owner, &native_token, &executor, value as i128);
-    let sub_invokes_with_transfer = MockAuthInvoke {
-        contract: &native_token,
-        fn_name: "transfer",
-        args: (&executor, &counter.address, &(value as i128)).into_val(&env),
-        sub_invokes: &[],
-    };
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "lz_compose",
-            args: (&executor, &from, &guid, &0_u32, &message, &extra_data, &(value as i128)).into_val(&env),
-            sub_invokes: &[sub_invokes_with_transfer],
-        },
-    }]);
-
-    counter.lz_compose(&executor, &from, &guid, &0, &message, &extra_data, &(value as i128));
-
-    assert_eq!(counter.composed_count(), 1);
-}
-
-#[test]
-#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
-fn test_lz_compose_not_from_executor() {
-    let TestSetup { env, counter, .. } = setup();
-
-    let from = Address::generate(&env);
-    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
-    let guid = BytesN::from_array(&env, &[2u8; 32]);
-    let value = 100;
-    let message = codec::encode_with_value(&env, MsgType::Composed, origin.src_eid, value);
-    let executor = Address::generate(&env);
-    let extra_data = Bytes::new(&env);
-
-    counter.lz_compose(&executor, &from, &guid, &0, &message, &extra_data, &(value as i128));
-}
-
-#[test]
-fn test_lz_compose_aba() {
-    let TestSetup { env, owner, counter, native_token, .. } = setup();
-
-    let from = Address::generate(&env);
-    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
-    let guid = BytesN::from_array(&env, &[2u8; 32]);
-    let value = 100;
-    let message = codec::encode_with_value(&env, MsgType::ComposedABA, origin.src_eid, value);
-    let executor = Address::generate(&env);
-    let extra_data = Bytes::new(&env);
-
-    setup_mock_peer(&env, &owner, &counter, origin.src_eid);
-    mint_to(&env, &owner, &native_token, &executor, value as i128);
-    let sub_invokes_with_transfer = MockAuthInvoke {
-        contract: &native_token,
-        fn_name: "transfer",
-        args: (&executor, &counter.address, &(value as i128)).into_val(&env),
-        sub_invokes: &[],
-    };
-    env.mock_auths(&[MockAuth {
-        address: &executor,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "lz_compose",
-            args: (&executor, &from, &guid, &0_u32, &message, &extra_data, &(value as i128)).into_val(&env),
-            sub_invokes: &[sub_invokes_with_transfer],
-        },
-    }]);
-
-    counter.lz_compose(&executor, &from, &guid, &0_u32, &message, &extra_data, &(value as i128));
-
-    assert_eq!(counter.composed_count(), 1);
-    assert_eq!(counter.outbound_count(&origin.src_eid), 1);
-}
-
-// tests for one step functions
-
-#[test]
-fn test_next_nonce() {
-    let TestSetup { env, owner, counter, .. } = setup();
-
-    let src_eid = 101;
-    let sender = BytesN::from_array(&env, &[1u8; 32]);
-    let nonce = counter.next_nonce(&src_eid, &sender);
-    assert_eq!(nonce, 0);
-
-    set_ordered_nonce(&env, &owner, &counter, true);
-    let nonce = counter.next_nonce(&src_eid, &sender);
-    assert_eq!(nonce, 1);
-}
-
-#[test]
-fn test_skip_inbound_nonce() {
-    let TestSetup { env, owner, counter, .. } = setup();
-
-    let src_eid = 101;
-    let sender = BytesN::from_array(&env, &[1u8; 32]);
-    let nonce = 1;
-
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "skip_inbound_nonce",
-            args: (&src_eid, &sender, &nonce).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    counter.skip_inbound_nonce(&src_eid, &sender, &nonce);
-}
-
-#[test]
-#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
-fn test_skip_inbound_nonce_no_owner() {
-    let TestSetup { env, counter, .. } = setup();
-
-    let src_eid = 101;
-    let sender = BytesN::from_array(&env, &[1u8; 32]);
-    let nonce = 1;
-
-    let non_owner = Address::generate(&env);
-    env.mock_auths(&[MockAuth {
-        address: &non_owner,
-        invoke: &MockAuthInvoke {
-            contract: &counter.address,
-            fn_name: "skip_inbound_nonce",
-            args: (&src_eid, &sender, &nonce).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-
-    counter.skip_inbound_nonce(&src_eid, &sender, &nonce);
-}

package/contracts/oapps/counter/src/tests/test_u256_ext.rs

@@ -1,48 +0,0 @@
-use crate::u256_ext::U256Ext;
-use soroban_sdk::{Env, U256};
-
-#[test]
-fn test_to_i128_with_small_value() {
-    let env = Env::default();
-    let val = U256::from_u128(&env, 100);
-    assert_eq!(val.to_i128(), Some(100i128));
-}
-
-#[test]
-fn test_to_i128_with_zero() {
-    let env = Env::default();
-    let val = U256::from_u128(&env, 0);
-    assert_eq!(val.to_i128(), Some(0i128));
-}
-
-#[test]
-fn test_to_i128_with_i128_max() {
-    let env = Env::default();
-    let val = U256::from_u128(&env, i128::MAX as u128);
-    assert_eq!(val.to_i128(), Some(i128::MAX));
-}
-
-#[test]
-fn test_to_i128_with_value_larger_than_i128_max_returns_none() {
-    let env = Env::default();
-    // i128::MAX + 1 should not fit in i128
-    let val = U256::from_u128(&env, (i128::MAX as u128) + 1);
-    assert_eq!(val.to_i128(), None);
-}
-
-#[test]
-fn test_to_i128_with_u128_max_returns_none() {
-    let env = Env::default();
-    let val = U256::from_u128(&env, u128::MAX);
-    assert_eq!(val.to_i128(), None);
-}
-
-#[test]
-fn test_to_i128_with_high_bits_set_returns_none() {
-    let env = Env::default();
-    // Create a U256 with high 128 bits set (value > u128::MAX)
-    // from_parts takes (hi_hi, hi_lo, lo_hi, lo_lo) where each is u64
-    // Setting hi_hi or hi_lo to non-zero makes it > u128::MAX
-    let val = U256::from_parts(&env, 1, 0, 0, 0); // Sets bits 192-255
-    assert_eq!(val.to_i128(), None);
-}

package/contracts/oapps/counter/src/u256_ext.rs

@@ -1,21 +0,0 @@
-use soroban_sdk::U256;
-
-pub trait U256Ext {
-    /// Converts U256 to i128 if the value fits.
-    /// Returns None if the value is too large to fit in an i128.
-    fn to_i128(&self) -> Option<i128>;
-}
-
-impl U256Ext for U256 {
-    fn to_i128(&self) -> Option<i128> {
-        // First try to convert to u128 (checks if high 128 bits are zero)
-        let u128_val = self.to_u128()?;
-
-        // Check if the u128 value fits within i128::MAX
-        if u128_val <= i128::MAX as u128 {
-            Some(u128_val as i128)
-        } else {
-            None
-        }
-    }
-}

package/contracts/oapps/lib.rs

@@ -1,2 +0,0 @@
-#![no_std]
-// This is an empty library crate that serves as a parent for message-lib packages

package/contracts/oapps/oapp/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-name = "oapp"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[lib]
-crate-type = ["rlib"]
-doctest = false
-
-[dependencies]
-soroban-sdk = { workspace = true }
-# workspace dependencies
-utils = { workspace = true }
-common-macros = { workspace = true }
-endpoint-v2 = { workspace = true, features = ["library"] }
-oapp-macros = { workspace = true }
-
-[dev-dependencies]
-soroban-sdk = { workspace = true, features = ["testutils"] }
-utils = { workspace = true, features = ["testutils"] }
-endpoint-v2 = { workspace = true, features = ["testutils"] }

package/contracts/oapps/oapp/src/errors.rs

@@ -1,13 +0,0 @@
-use common_macros::contract_error;
-
-// OApp library error codes: 2000-2099
-// See docs/error-spec.md for allocation rules
-
-/// OAppError: 2000-2099
-#[contract_error]
-pub enum OAppError {
-    InvalidOptions = 2000,
-    NoPeer,
-    OnlyPeer,
-    ZroTokenUnavailable,
-}

package/contracts/oapps/oapp/src/interfaces/mod.rs

@@ -1,3 +0,0 @@
-mod oapp_msg_inspector;
-
-pub use oapp_msg_inspector::*;

package/contracts/oapps/oapp/src/interfaces/oapp_msg_inspector.rs

@@ -1,70 +0,0 @@
-//! OApp Message Inspector interface.
-//!
-//! This module defines the `IOAppMsgInspector` trait that external inspector contracts
-//! must implement to validate outgoing LayerZero messages and options.
-//!
-//! Implementations can signal failure in two ways:
-//! - Return `false` to indicate the inspection failed.
-//! - Panic directly to abort the transaction immediately.
-//!
-//! ## Usage
-//!
-//! ### Returning a boolean
-//!
-//! ```ignore
-//! use oapp::interfaces::IOAppMsgInspector;
-//!
-//! pub struct MyInspector;
-//!
-//! #[contractimpl]
-//! impl IOAppMsgInspector for MyInspector {
-//!     fn inspect(env: &Env, oapp: &Address, message: &Bytes, options: &Bytes) -> bool {
-//!         is_valid(message, options)
-//!     }
-//! }
-//! ```
-//!
-//! ### Panicking on failure
-//!
-//! ```ignore
-//! use oapp::interfaces::IOAppMsgInspector;
-//!
-//! pub struct MyInspector;
-//!
-//! #[contractimpl]
-//! impl IOAppMsgInspector for MyInspector {
-//!     fn inspect(env: &Env, oapp: &Address, message: &Bytes, options: &Bytes) -> bool {
-//!         if !is_valid(message, options) {
-//!             panic_with_error!(env, MyError::InspectionFailed);
-//!         }
-//!         true
-//!     }
-//! }
-//! ```
-
-use soroban_sdk::{contractclient, Address, Bytes, Env};
-
-/// Interface for OApp message inspectors.
-///
-/// Contracts implementing this trait can be set as message inspectors on OFT contracts
-/// to validate outgoing messages and options before they are sent cross-chain.
-///
-/// Implementations may either return `false` to indicate failure, or panic directly
-/// to abort the transaction.
-#[contractclient(name = "OAppMsgInspectorClient")]
-pub trait IOAppMsgInspector {
-    /// Allows the inspector to examine LayerZero message contents and determine their validity.
-    ///
-    /// # Arguments
-    /// * `oapp` - The address of the OApp contract sending the message
-    /// * `message` - The message payload to be inspected.
-    /// * `options` - Additional LayerZero options for inspection.
-    ///
-    /// # Returns
-    /// * `bool` - `true` if the inspection passed, `false` if the message or options are invalid.
-    ///
-    /// # Panics
-    /// Implementations may choose to panic instead of returning `false` to abort the
-    /// transaction immediately with a specific error.
-    fn inspect(env: &Env, oapp: &Address, message: &Bytes, options: &Bytes) -> bool;
-}