@layerzerolabs/protocol-stellar-v2 0.2.20 → 0.2.21

package/contracts/macro-integration-tests/tests/runtime/oapp/sender.rs

@@ -0,0 +1,435 @@
+// Runtime tests: OAppSenderInternal defaults generated by `#[oapp]`.
+
+use endpoint_v2::{MessagingFee, MessagingParams, MessagingReceipt, Origin};
+use oapp::errors::OAppError;
+use oapp::oapp_receiver::LzReceiveInternal;
+use oapp_macros::oapp;
+use soroban_sdk::{
+    contract, contractimpl, symbol_short,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    token::{StellarAssetClient, TokenClient},
+    Address, Bytes, BytesN, Env, IntoVal,
+};
+
+const REMOTE_EID: u32 = 100;
+const UNSET_EID: u32 = 999;
+
+// Mock Endpoint contract (subset used by sender internals).
+#[contract]
+pub struct MockEndpoint;
+
+#[contractimpl]
+impl MockEndpoint {
+    pub fn __constructor(env: Env, zro_token: Address, native_token: Address) {
+        env.storage().instance().set(&symbol_short!("zro"), &Some(zro_token));
+        env.storage().instance().set(&symbol_short!("ntk"), &native_token);
+    }
+
+    pub fn set_delegate(_env: Env, _oapp: Address, _delegate: Option<Address>) {
+        // no-op
+    }
+
+    pub fn quote(env: Env, sender: Address, params: MessagingParams) -> MessagingFee {
+        env.storage().instance().set(&symbol_short!("qts"), &sender);
+        env.storage().instance().set(&symbol_short!("qtp"), &params);
+        MessagingFee { native_fee: 1000, zro_fee: if params.pay_in_zro { 500 } else { 0 } }
+    }
+
+    pub fn send(env: Env, sender: Address, params: MessagingParams, refund_address: Address) -> MessagingReceipt {
+        env.storage().instance().set(&symbol_short!("snds"), &sender);
+        env.storage().instance().set(&symbol_short!("sndp"), &params);
+        env.storage().instance().set(&symbol_short!("sndr"), &refund_address);
+        MessagingReceipt {
+            guid: BytesN::from_array(&env, &[1u8; 32]),
+            nonce: 1,
+            fee: MessagingFee { native_fee: 1000, zro_fee: if params.pay_in_zro { 500 } else { 0 } },
+        }
+    }
+
+    pub fn last_send(env: Env) -> (Address, MessagingParams, Address) {
+        (
+            env.storage().instance().get(&symbol_short!("snds")).unwrap(),
+            env.storage().instance().get(&symbol_short!("sndp")).unwrap(),
+            env.storage().instance().get(&symbol_short!("sndr")).unwrap(),
+        )
+    }
+
+    pub fn last_quote(env: Env) -> (Address, MessagingParams) {
+        (
+            env.storage().instance().get(&symbol_short!("qts")).unwrap(),
+            env.storage().instance().get(&symbol_short!("qtp")).unwrap(),
+        )
+    }
+
+    pub fn zro(env: Env) -> Option<Address> {
+        env.storage().instance().get(&symbol_short!("zro")).unwrap_or(None)
+    }
+
+    pub fn native_token(env: Env) -> Address {
+        env.storage().instance().get(&symbol_short!("ntk")).unwrap()
+    }
+
+    pub fn set_zro(env: Env, zro: Option<Address>) {
+        env.storage().instance().set(&symbol_short!("zro"), &zro);
+    }
+}
+
+#[oapp]
+pub struct TestOAppSender;
+
+impl LzReceiveInternal for TestOAppSender {
+    fn __lz_receive(
+        _env: &Env,
+        _origin: &Origin,
+        _guid: &BytesN<32>,
+        _message: &Bytes,
+        _extra_data: &Bytes,
+        _executor: &Address,
+        _value: i128,
+    ) {
+    }
+}
+
+#[contractimpl]
+impl TestOAppSender {
+    pub fn init(env: Env, owner: Address, endpoint: Address) {
+        oapp::oapp_core::initialize_oapp::<Self>(&env, &owner, &endpoint, &None::<Address>);
+    }
+
+    pub fn quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
+        Self::__quote(env, dst_eid, message, options, pay_in_zro)
+    }
+
+    pub fn send(
+        env: &Env,
+        sender: &Address,
+        dst_eid: u32,
+        message: &Bytes,
+        options: &Bytes,
+        fee: &MessagingFee,
+        refund_address: &Address,
+    ) -> MessagingReceipt {
+        sender.require_auth();
+        Self::__lz_send(env, dst_eid, message, options, sender, fee, refund_address)
+    }
+}
+
+fn set_peer(
+    env: &Env,
+    owner: &Address,
+    oapp: &Address,
+    client: &TestOAppSenderClient<'_>,
+    eid: u32,
+    peer: &BytesN<32>,
+) {
+    let peer_opt = Some(peer.clone());
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: oapp,
+            fn_name: "set_peer",
+            args: (&eid, &peer_opt).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    client.set_peer(&eid, &peer_opt);
+}
+
+fn mint_to(
+    env: &Env,
+    token_admin: &Address,
+    token: &Address,
+    token_admin_client: &StellarAssetClient<'_>,
+    to: &Address,
+    amount: i128,
+) {
+    env.mock_auths(&[MockAuth {
+        address: token_admin,
+        invoke: &MockAuthInvoke {
+            contract: token,
+            fn_name: "mint",
+            args: (to, amount).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_admin_client.mint(to, &amount);
+}
+
+struct Setup {
+    env: Env,
+    owner: Address,
+    token_admin: Address,
+
+    native_token: Address,
+    zro_token: Address,
+
+    endpoint: Address,
+    oapp: Address,
+}
+
+impl Setup {
+    fn oapp_client(&self) -> TestOAppSenderClient<'_> {
+        TestOAppSenderClient::new(&self.env, &self.oapp)
+    }
+
+    fn endpoint_client(&self) -> MockEndpointClient<'_> {
+        MockEndpointClient::new(&self.env, &self.endpoint)
+    }
+
+    fn native_token_client(&self) -> TokenClient<'_> {
+        TokenClient::new(&self.env, &self.native_token)
+    }
+
+    fn native_token_admin_client(&self) -> StellarAssetClient<'_> {
+        StellarAssetClient::new(&self.env, &self.native_token)
+    }
+
+    fn zro_token_client(&self) -> TokenClient<'_> {
+        TokenClient::new(&self.env, &self.zro_token)
+    }
+
+    fn zro_token_admin_client(&self) -> StellarAssetClient<'_> {
+        StellarAssetClient::new(&self.env, &self.zro_token)
+    }
+}
+
+fn setup() -> Setup {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let token_admin = Address::generate(&env);
+
+    let native_token_sac = env.register_stellar_asset_contract_v2(token_admin.clone());
+    let native_token = native_token_sac.address();
+
+    let zro_token_sac = env.register_stellar_asset_contract_v2(token_admin.clone());
+    let zro_token = zro_token_sac.address();
+
+    let endpoint = env.register(MockEndpoint, (&zro_token, &native_token));
+
+    let oapp = env.register(TestOAppSender, ());
+    let client = TestOAppSenderClient::new(&env, &oapp);
+    client.init(&owner, &endpoint);
+
+    Setup { env, owner, token_admin, native_token, zro_token, endpoint, oapp }
+}
+
+#[test]
+fn quote_with_peer_set_works_and_no_peer_errors() {
+    let context = setup();
+    let env = &context.env;
+    let client = context.oapp_client();
+
+    let peer = BytesN::from_array(env, &[1u8; 32]);
+    set_peer(env, &context.owner, &context.oapp, &client, REMOTE_EID, &peer);
+
+    let message = Bytes::from_array(env, &[1, 2, 3]);
+    let options = Bytes::new(env);
+
+    let fee = client.quote(&REMOTE_EID, &message, &options, &false);
+    assert_eq!(fee.native_fee, 1000);
+    assert_eq!(fee.zro_fee, 0);
+
+    let (quote_sender, quote_params) = context.endpoint_client().last_quote();
+    assert_eq!(quote_sender, context.oapp);
+    assert_eq!(quote_params.dst_eid, REMOTE_EID);
+    assert_eq!(quote_params.receiver, peer);
+    assert_eq!(quote_params.message, message);
+    assert_eq!(quote_params.options, options);
+    assert_eq!(quote_params.pay_in_zro, false);
+
+    let fee_zro = client.quote(&REMOTE_EID, &message, &options, &true);
+    assert_eq!(fee_zro.native_fee, 1000);
+    assert_eq!(fee_zro.zro_fee, 500);
+
+    let (_quote_sender, quote_params) = context.endpoint_client().last_quote();
+    assert_eq!(quote_params.pay_in_zro, true);
+
+    // No peer configured for UNSET_EID => error
+    let no_peer = client.try_quote(&UNSET_EID, &message, &options, &false);
+    assert_eq!(no_peer.err().unwrap().ok().unwrap(), OAppError::NoPeer.into());
+}
+
+#[test]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn lz_send_requires_sender_auth() {
+    let context = setup();
+    let env = &context.env;
+    let client = context.oapp_client();
+
+    // No env.mock_auths for sender => should panic at sender.require_auth().
+    let sender = Address::generate(env);
+    let fee = MessagingFee { native_fee: 0, zro_fee: 0 };
+    let message = Bytes::new(env);
+    let options = Bytes::new(env);
+    let refund = Address::generate(env);
+    client.send(&sender, &REMOTE_EID, &message, &options, &fee, &refund);
+}
+
+#[test]
+fn lz_send_pays_native_and_zro_and_calls_endpoint_send() {
+    let context = setup();
+    let env = &context.env;
+    let client = context.oapp_client();
+
+    let peer = BytesN::from_array(env, &[2u8; 32]);
+    set_peer(env, &context.owner, &context.oapp, &client, REMOTE_EID, &peer);
+
+    let sender = Address::generate(env);
+    let fee = MessagingFee { native_fee: 1000, zro_fee: 500 };
+    mint_to(
+        env,
+        &context.token_admin,
+        &context.native_token,
+        &context.native_token_admin_client(),
+        &sender,
+        fee.native_fee,
+    );
+    mint_to(env, &context.token_admin, &context.zro_token, &context.zro_token_admin_client(), &sender, fee.zro_fee);
+
+    let message = Bytes::from_array(env, &[9, 9, 9]);
+    let options = Bytes::from_array(env, &[7]);
+    let refund = Address::generate(env);
+
+    // send() requires sender auth and will sub-invoke token transfers.
+    let native_transfer = MockAuthInvoke {
+        contract: &context.native_token,
+        fn_name: "transfer",
+        args: (&sender, &context.endpoint, &fee.native_fee).into_val(env),
+        sub_invokes: &[],
+    };
+    let zro_transfer = MockAuthInvoke {
+        contract: &context.zro_token,
+        fn_name: "transfer",
+        args: (&sender, &context.endpoint, &fee.zro_fee).into_val(env),
+        sub_invokes: &[],
+    };
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.oapp,
+            fn_name: "send",
+            args: (&sender, &REMOTE_EID, &message, &options, &fee, &refund).into_val(env),
+            sub_invokes: &[native_transfer, zro_transfer],
+        },
+    }]);
+
+    let receipt = client.send(&sender, &REMOTE_EID, &message, &options, &fee, &refund);
+    assert_eq!(receipt.nonce, 1);
+    assert_eq!(receipt.fee.native_fee, 1000);
+    assert_eq!(receipt.fee.zro_fee, 500);
+
+    let (endpoint_sender, params, got_refund) = context.endpoint_client().last_send();
+    assert_eq!(endpoint_sender, context.oapp);
+    assert_eq!(params.dst_eid, REMOTE_EID);
+    assert_eq!(params.receiver, peer);
+    assert_eq!(params.message, message);
+    assert_eq!(params.options, options);
+    assert_eq!(params.pay_in_zro, true);
+    assert_eq!(got_refund, refund);
+
+    let native_token_client = context.native_token_client();
+    let zro_token_client = context.zro_token_client();
+    assert_eq!(native_token_client.balance(&sender), 0);
+    assert_eq!(native_token_client.balance(&context.endpoint), 1000);
+    assert_eq!(zro_token_client.balance(&sender), 0);
+    assert_eq!(zro_token_client.balance(&context.endpoint), 500);
+}
+
+#[test]
+fn lz_send_native_only_does_not_pay_zro() {
+    let context = setup();
+    let env = &context.env;
+    let client = context.oapp_client();
+
+    let peer = BytesN::from_array(env, &[3u8; 32]);
+    set_peer(env, &context.owner, &context.oapp, &client, REMOTE_EID, &peer);
+
+    let sender = Address::generate(env);
+    let fee = MessagingFee { native_fee: 1000, zro_fee: 0 };
+    mint_to(
+        env,
+        &context.token_admin,
+        &context.native_token,
+        &context.native_token_admin_client(),
+        &sender,
+        fee.native_fee,
+    );
+    mint_to(env, &context.token_admin, &context.zro_token, &context.zro_token_admin_client(), &sender, 100);
+
+    let message = Bytes::from_array(env, &[1, 2, 3]);
+    let options = Bytes::new(env);
+    let refund = Address::generate(env);
+
+    let native_transfer = MockAuthInvoke {
+        contract: &context.native_token,
+        fn_name: "transfer",
+        args: (&sender, &context.endpoint, &fee.native_fee).into_val(env),
+        sub_invokes: &[],
+    };
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.oapp,
+            fn_name: "send",
+            args: (&sender, &REMOTE_EID, &message, &options, &fee, &refund).into_val(env),
+            sub_invokes: &[native_transfer],
+        },
+    }]);
+
+    let receipt = client.send(&sender, &REMOTE_EID, &message, &options, &fee, &refund);
+    assert_eq!(receipt.fee.native_fee, 1000);
+    assert_eq!(receipt.fee.zro_fee, 0);
+
+    let (_endpoint_sender, params, _refund) = context.endpoint_client().last_send();
+    assert_eq!(params.pay_in_zro, false);
+
+    let native_token_client = context.native_token_client();
+    let zro_token_client = context.zro_token_client();
+    assert_eq!(native_token_client.balance(&sender), 0);
+    assert_eq!(native_token_client.balance(&context.endpoint), 1000);
+    assert_eq!(zro_token_client.balance(&context.endpoint), 0);
+    assert_eq!(zro_token_client.balance(&sender), 100);
+}
+
+#[test]
+fn pay_zro_unavailable_returns_error() {
+    let context = setup();
+    let env = &context.env;
+    let client = context.oapp_client();
+    context.endpoint_client().set_zro(&None);
+
+    let sender = Address::generate(env);
+    let fee = MessagingFee { native_fee: 1000, zro_fee: 500 };
+    mint_to(
+        env,
+        &context.token_admin,
+        &context.native_token,
+        &context.native_token_admin_client(),
+        &sender,
+        fee.native_fee,
+    );
+
+    let message = Bytes::from_array(env, &[1, 2, 3]);
+    let options = Bytes::new(env);
+    let refund = Address::generate(env);
+
+    // send() requires sender auth and will sub-invoke native fee transfer.
+    let native_transfer = MockAuthInvoke {
+        contract: &context.native_token,
+        fn_name: "transfer",
+        args: (&sender, &context.endpoint, &fee.native_fee).into_val(env),
+        sub_invokes: &[],
+    };
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &context.oapp,
+            fn_name: "send",
+            args: (&sender, &REMOTE_EID, &message, &options, &fee, &refund).into_val(env),
+            sub_invokes: &[native_transfer],
+        },
+    }]);
+
+    let result = client.try_send(&sender, &REMOTE_EID, &message, &options, &fee, &refund);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::ZroTokenUnavailable.into());
+}

package/contracts/macro-integration-tests/tests/runtime.rs

@@ -1,4 +1,5 @@
 mod runtime {
+    mod oapp;
     mod ownable;
     mod storage;
     mod ttl_configurable;

package/contracts/macro-integration-tests/tests/ui/oapp/fail/custom_wrong_value.rs

@@ -0,0 +1,8 @@
+// UI (trybuild) negative test: `custom` must be a bracketed list.
+
+use oapp_macros::oapp;
+
+#[oapp(custom = core)]
+pub struct MyOApp;
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/oapp/fail/custom_wrong_value.stderr

@@ -0,0 +1,5 @@
+error: expected square brackets
+ --> tests/ui/oapp/fail/custom_wrong_value.rs:5:17
+  |
+5 | #[oapp(custom = core)]
+  |                 ^^^^

package/contracts/macro-integration-tests/tests/ui/oapp/fail/missing_lz_receive_internal.rs

@@ -0,0 +1,8 @@
+// UI (trybuild) negative test: `#[oapp]` requires `LzReceiveInternal` to be implemented.
+
+use oapp_macros::oapp;
+
+#[oapp]
+pub struct MyOApp;
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/oapp/fail/missing_lz_receive_internal.stderr

@@ -0,0 +1,71 @@
+error[E0277]: the trait bound `MyOApp: LzReceiveInternal` is not satisfied
+ --> tests/ui/oapp/fail/missing_lz_receive_internal.rs:6:12
+  |
+6 | pub struct MyOApp;
+  |            ^^^^^^ the trait `LzReceiveInternal` is not implemented for `MyOApp`
+  |
+note: required by a bound in `OAppReceiver`
+ --> $WORKSPACE/contracts/oapps/oapp/src/oapp_receiver.rs
+  |
+  | pub trait OAppReceiver: OAppCore + LzReceiveInternal {
+  |                                    ^^^^^^^^^^^^^^^^^ required by this bound in `OAppReceiver`
+
+error[E0277]: the trait bound `MyOApp: LzReceiveInternal` is not satisfied
+ --> tests/ui/oapp/fail/missing_lz_receive_internal.rs:6:12
+  |
+6 | pub struct MyOApp;
+  |            ^^^^^^ the trait `LzReceiveInternal` is not implemented for `MyOApp`
+  |
+note: required by a bound in `oapp::oapp_receiver::OAppReceiver::allow_initialize_path`
+ --> $WORKSPACE/contracts/oapps/oapp/src/oapp_receiver.rs
+  |
+  | pub trait OAppReceiver: OAppCore + LzReceiveInternal {
+  |                                    ^^^^^^^^^^^^^^^^^ required by this bound in `OAppReceiver::allow_initialize_path`
+...
+  |     fn allow_initialize_path(env: &soroban_sdk::Env, origin: &endpoint_v2::Origin) -> bool {
+  |        --------------------- required by a bound in this associated function
+
+error[E0277]: the trait bound `MyOApp: LzReceiveInternal` is not satisfied
+ --> tests/ui/oapp/fail/missing_lz_receive_internal.rs:6:12
+  |
+6 | pub struct MyOApp;
+  |            ^^^^^^ the trait `LzReceiveInternal` is not implemented for `MyOApp`
+  |
+note: required by a bound in `oapp::oapp_receiver::OAppReceiver::next_nonce`
+ --> $WORKSPACE/contracts/oapps/oapp/src/oapp_receiver.rs
+  |
+  | pub trait OAppReceiver: OAppCore + LzReceiveInternal {
+  |                                    ^^^^^^^^^^^^^^^^^ required by this bound in `OAppReceiver::next_nonce`
+...
+  |     fn next_nonce(_env: &soroban_sdk::Env, _src_eid: u32, _sender: &soroban_sdk::BytesN<32>) -> u64 {
+  |        ---------- required by a bound in this associated function
+
+error[E0277]: the trait bound `MyOApp: LzReceiveInternal` is not satisfied
+ --> tests/ui/oapp/fail/missing_lz_receive_internal.rs:6:12
+  |
+6 | pub struct MyOApp;
+  |            ^^^^^^ the trait `LzReceiveInternal` is not implemented for `MyOApp`
+  |
+note: required by a bound in `oapp::oapp_receiver::OAppReceiver::lz_receive`
+ --> $WORKSPACE/contracts/oapps/oapp/src/oapp_receiver.rs
+  |
+  | pub trait OAppReceiver: OAppCore + LzReceiveInternal {
+  |                                    ^^^^^^^^^^^^^^^^^ required by this bound in `OAppReceiver::lz_receive`
+...
+  |     fn lz_receive(
+  |        ---------- required by a bound in this associated function
+
+error[E0277]: the trait bound `MyOApp: LzReceiveInternal` is not satisfied
+ --> tests/ui/oapp/fail/missing_lz_receive_internal.rs:6:12
+  |
+6 | pub struct MyOApp;
+  |            ^^^^^^ the trait `LzReceiveInternal` is not implemented for `MyOApp`
+  |
+note: required by a bound in `is_compose_msg_sender`
+ --> $WORKSPACE/contracts/oapps/oapp/src/oapp_receiver.rs
+  |
+  | pub trait OAppReceiver: OAppCore + LzReceiveInternal {
+  |                                    ^^^^^^^^^^^^^^^^^ required by this bound in `OAppReceiver::is_compose_msg_sender`
+...
+  |     fn is_compose_msg_sender(
+  |        --------------------- required by a bound in this associated function

package/contracts/macro-integration-tests/tests/ui/oapp/fail/non_struct_input.rs

@@ -0,0 +1,10 @@
+// UI (trybuild) negative test: `#[oapp]` must be applied to a struct.
+
+use oapp_macros::oapp;
+
+#[oapp]
+pub enum NotAStruct {
+    A,
+}
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/oapp/fail/non_struct_input.stderr

@@ -0,0 +1,5 @@
+error: expected `struct`
+ --> tests/ui/oapp/fail/non_struct_input.rs:6:5
+  |
+6 | pub enum NotAStruct {
+  |     ^^^^

package/contracts/macro-integration-tests/tests/ui/oapp/fail/unknown_custom_option.rs

@@ -0,0 +1,8 @@
+// UI (trybuild) negative test: unknown `custom` option is rejected.
+
+use oapp_macros::oapp;
+
+#[oapp(custom = [core, not_a_real_option])]
+pub struct MyOApp;
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/oapp/fail/unknown_custom_option.stderr

@@ -0,0 +1,5 @@
+error: expected one of `core`, `sender`, `receiver`, `options_type3`
+ --> tests/ui/oapp/fail/unknown_custom_option.rs:5:24
+  |
+5 | #[oapp(custom = [core, not_a_real_option])]
+  |                        ^^^^^^^^^^^^^^^^^

package/contracts/macro-integration-tests/tests/ui/oapp/fail/wrong_key.rs

@@ -0,0 +1,8 @@
+// UI (trybuild) negative test: only `custom = [...]` is accepted.
+
+use oapp_macros::oapp;
+
+#[oapp(nope = [core])]
+pub struct MyOApp;
+
+fn main() {}

package/contracts/macro-integration-tests/tests/ui/oapp/fail/wrong_key.stderr

@@ -0,0 +1,5 @@
+error: expected `custom`
+ --> tests/ui/oapp/fail/wrong_key.rs:5:8
+  |
+5 | #[oapp(nope = [core])]
+  |        ^^^^

package/contracts/macro-integration-tests/tests/ui/oapp/pass/custom_all.rs

@@ -0,0 +1,38 @@
+// UI (trybuild) test: `#[oapp(custom = [core, sender, receiver, options_type3])]` works.
+
+use endpoint_v2::Origin;
+use oapp::oapp_core::OAppCore;
+use oapp::oapp_options_type3::OAppOptionsType3;
+use oapp::oapp_receiver::{LzReceiveInternal, OAppReceiver};
+use oapp::oapp_sender::OAppSenderInternal;
+use oapp_macros::oapp;
+use soroban_sdk::{contractimpl, Address, Bytes, BytesN, Env};
+
+#[oapp(custom = [core, sender, receiver, options_type3])]
+pub struct MyOApp;
+
+impl LzReceiveInternal for MyOApp {
+    fn __lz_receive(
+        _env: &Env,
+        _origin: &Origin,
+        _guid: &BytesN<32>,
+        _message: &Bytes,
+        _extra_data: &Bytes,
+        _executor: &Address,
+        _value: i128,
+    ) {
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OAppCore for MyOApp {}
+
+impl OAppSenderInternal for MyOApp {}
+
+#[contractimpl(contracttrait)]
+impl OAppReceiver for MyOApp {}
+
+#[contractimpl(contracttrait)]
+impl OAppOptionsType3 for MyOApp {}
+
+fn main() {}