@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.123

package/contracts/oapps/counter/integration_tests/utils.rs

@@ -1,294 +0,0 @@
-//! Common utilities shared between SML and ULN302 integration tests.
-
-extern crate std;
-
-use crate::{codec::MsgType, counter::CounterClient, tests::mint_to};
-use endpoint_v2::{EndpointV2Client, MessagingFee, Origin, OutboundPacket};
-use message_lib_common::packet_codec_v1;
-use soroban_sdk::{
-    address_payload::AddressPayload,
-    testutils::{Events, MockAuth, MockAuthInvoke},
-    Address, Bytes, BytesN, Env, IntoVal, Map, Symbol, Val, Vec,
-};
-use utils::buffer_reader::BufferReader;
-use utils::testing_utils::decode_event_topics_data;
-
-/// Trait for common fields in chain setup structs.
-/// Both SML and ULN302 ChainSetup implement this trait.
-pub trait ChainSetupCommon<'a> {
-    fn counter(&self) -> &CounterClient<'a>;
-    fn endpoint(&self) -> &EndpointV2Client<'a>;
-    fn native_token(&self) -> &Address;
-    fn owner(&self) -> &Address;
-    /// Validates a packet using the message library's verification mechanism.
-    /// SML calls validate_packet, ULN302 does DVN verify + commit.
-    fn validate_packet(&self, env: &Env, packet_event: &(Bytes, Bytes, Address)) -> OutboundPacket;
-}
-
-/// Converts an Address into its 32-byte payload.
-pub fn address_to_bytes32(address: &Address) -> BytesN<32> {
-    match address.to_payload().unwrap() {
-        AddressPayload::AccountIdPublicKeyEd25519(payload) => payload,
-        AddressPayload::ContractIdHash(payload) => payload,
-    }
-}
-
-/// Sets the ZRO token on the endpoint with owner authorization.
-pub fn set_zro(env: &Env, owner: &Address, endpoint: &EndpointV2Client<'_>, zro_token: &Address) {
-    env.mock_auths(&[MockAuth {
-        address: owner,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint.address,
-            fn_name: "set_zro",
-            args: (zro_token,).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint.set_zro(zro_token);
-}
-
-/// Registers a message library on the endpoint with owner authorization.
-pub fn register_library(env: &Env, owner: &Address, endpoint: &EndpointV2Client<'_>, lib: &Address) {
-    env.mock_auths(&[MockAuth {
-        address: owner,
-        invoke: &MockAuthInvoke {
-            contract: &endpoint.address,
-            fn_name: "register_library",
-            args: (lib,).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    endpoint.register_library(lib);
-}
-
-/// Sets the peer address for a counter on a destination EID.
-pub fn set_peer(env: &Env, owner: &Address, counter: &CounterClient<'_>, dst_eid: u32, peer: &BytesN<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);
-}
-
-/// Decodes an outbound packet emitted by the endpoint.
-pub fn decode_packet(env: &Env, encoded_packet: &Bytes) -> OutboundPacket {
-    let header = packet_codec_v1::decode_packet_header(env, &encoded_packet.slice(0..packet_codec_v1::HEADER_LENGTH));
-    let payload = encoded_packet.slice(packet_codec_v1::HEADER_LENGTH..);
-
-    let mut payload_reader = BufferReader::new(&payload);
-    let guid = payload_reader.read_bytes_n::<32>();
-    let message = payload_reader.read_bytes_until_end();
-
-    OutboundPacket {
-        nonce: header.nonce,
-        src_eid: header.src_eid,
-        sender: Address::from_payload(env, AddressPayload::ContractIdHash(header.sender)),
-        dst_eid: header.dst_eid,
-        receiver: header.receiver,
-        guid,
-        message,
-    }
-}
-
-pub fn quote<'a, C: ChainSetupCommon<'a>>(chain: &C, dst_eid: u32, msg_type: MsgType, options: &Bytes) -> MessagingFee {
-    chain.counter().quote(&dst_eid, &(msg_type as u32), options, &false)
-}
-
-pub fn increment<'a, C: ChainSetupCommon<'a>>(
-    env: &Env,
-    chain: &C,
-    sender: &Address,
-    dst_eid: u32,
-    msg_type: MsgType,
-    options: &Bytes,
-    fee: &MessagingFee,
-) {
-    let msg_type = msg_type as u32;
-    env.mock_auths(&[MockAuth {
-        address: sender,
-        invoke: &MockAuthInvoke {
-            contract: &chain.counter().address,
-            fn_name: "increment",
-            args: (sender, &dst_eid, &msg_type, options, fee).into_val(env),
-            sub_invokes: &[MockAuthInvoke {
-                contract: chain.native_token(),
-                fn_name: "transfer",
-                args: (sender, &chain.endpoint().address, &fee.native_fee).into_val(env),
-                sub_invokes: &[],
-            }],
-        },
-    }]);
-    chain.counter().increment(sender, &dst_eid, &msg_type, options, fee);
-}
-
-/// Execute lz_receive on the counter contract.
-/// Automatically mints native tokens to the executor if value > 0.
-pub fn lz_receive<'a, C: ChainSetupCommon<'a>>(
-    env: &Env,
-    chain: &C,
-    executor: &Address,
-    packet: &OutboundPacket,
-    value: i128,
-) {
-    // Mint native tokens to executor if value > 0
-    if value > 0 {
-        mint_to(env, chain.owner(), chain.native_token(), executor, value);
-    }
-
-    let origin = Origin { src_eid: packet.src_eid, sender: address_to_bytes32(&packet.sender), nonce: packet.nonce };
-
-    let sub_invokes_with_transfer = [MockAuthInvoke {
-        contract: chain.native_token(),
-        fn_name: "transfer",
-        args: (executor, &chain.counter().address, &value).into_val(env),
-        sub_invokes: &[],
-    }];
-
-    env.mock_auths(&[MockAuth {
-        address: executor,
-        invoke: &MockAuthInvoke {
-            contract: &chain.counter().address,
-            fn_name: "lz_receive",
-            args: (executor, &origin, &packet.guid, &packet.message, &Bytes::new(env), &value).into_val(env),
-            sub_invokes: if value > 0 { &sub_invokes_with_transfer } else { &[] },
-        },
-    }]);
-    chain.counter().lz_receive(executor, &origin, &packet.guid, &packet.message, &Bytes::new(env), &value);
-}
-
-/// Execute lz_compose on the counter contract.
-/// Automatically mints native tokens to the executor if value > 0.
-pub fn lz_compose<'a, C: ChainSetupCommon<'a>>(
-    env: &Env,
-    chain: &C,
-    executor: &Address,
-    packet: &OutboundPacket,
-    value: i128,
-) {
-    // Mint native tokens to executor if value > 0
-    if value > 0 {
-        mint_to(env, chain.owner(), chain.native_token(), executor, value);
-    }
-
-    let sub_invokes_with_transfer = [MockAuthInvoke {
-        contract: chain.native_token(),
-        fn_name: "transfer",
-        args: (executor, &chain.counter().address, &value).into_val(env),
-        sub_invokes: &[],
-    }];
-
-    env.mock_auths(&[MockAuth {
-        address: executor,
-        invoke: &MockAuthInvoke {
-            contract: &chain.counter().address,
-            fn_name: "lz_compose",
-            args: (executor, &chain.counter().address, &packet.guid, &0_u32, &packet.message, &Bytes::new(env), &value)
-                .into_val(env),
-            sub_invokes: if value > 0 { &sub_invokes_with_transfer } else { &[] },
-        },
-    }]);
-    chain.counter().lz_compose(
-        executor,
-        &chain.counter().address,
-        &packet.guid,
-        &0,
-        &packet.message,
-        &Bytes::new(env),
-        &value,
-    );
-}
-
-/// Validates a packet using the chain's message library verification mechanism.
-/// This is a convenience wrapper around the trait method.
-pub fn validate_packet<'a, C: ChainSetupCommon<'a>>(
-    env: &Env,
-    chain: &C,
-    packet_event: &(Bytes, Bytes, Address),
-) -> OutboundPacket {
-    chain.validate_packet(env, packet_event)
-}
-
-/// Scans for the latest packet_sent event and returns (encoded_payload, options, send_library).
-pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, Bytes, Address)> {
-    let events = env.events().all().filter_by_contract(endpoint);
-    let packet_sent_symbol = Symbol::new(env, "packet_sent").to_val();
-
-    // Iterate in reverse to find the most recent packet sent event
-    for event in events.events().iter().rev() {
-        let Some((topics, data)) = decode_event_topics_data(env, event) else {
-            continue;
-        };
-        if topics.contains(packet_sent_symbol) {
-            let map: Map<Symbol, Val> = data.into_val(env);
-
-            let encoded_payload: Bytes = map.get(Symbol::new(env, "encoded_packet")).unwrap().into_val(env);
-            let options: Bytes = map.get(Symbol::new(env, "options")).unwrap().into_val(env);
-            let send_library: Address = map.get(Symbol::new(env, "send_library")).unwrap().into_val(env);
-
-            return Some((encoded_payload, options, send_library));
-        }
-    }
-
-    None
-}
-
-/// Scans for ALL packet_sent events from an endpoint and returns them in chronological order.
-/// NOTE: In Soroban test environment, events from previous contract calls may be cleared.
-/// Use this only after all messages have been sent in a single "transaction" or collect events incrementally.
-#[allow(dead_code)]
-pub fn scan_all_packet_sent_events(env: &Env, endpoint: &Address) -> Vec<(Bytes, Bytes, Address)> {
-    let events = env.events().all().filter_by_contract(endpoint);
-    let packet_sent_symbol = Symbol::new(env, "packet_sent").to_val();
-    let mut result = Vec::new(env);
-
-    for event in events.events().iter() {
-        let Some((topics, data)) = decode_event_topics_data(env, event) else {
-            continue;
-        };
-        if topics.contains(packet_sent_symbol) {
-            let map: Map<Symbol, Val> = data.into_val(env);
-
-            let encoded_payload: Bytes = map.get(Symbol::new(env, "encoded_packet")).unwrap().into_val(env);
-            let options: Bytes = map.get(Symbol::new(env, "options")).unwrap().into_val(env);
-            let send_library: Address = map.get(Symbol::new(env, "send_library")).unwrap().into_val(env);
-
-            result.push_back((encoded_payload, options, send_library));
-        }
-    }
-
-    result
-}
-
-/// Compose sent event data: (from, to, guid, index, message)
-pub type ComposeSentEvent = (Address, Address, BytesN<32>, u32, Bytes);
-
-/// Scans for the latest compose_sent event and returns (from, to, guid, index, message).
-pub fn scan_compose_sent_event(env: &Env, endpoint: &Address) -> Option<ComposeSentEvent> {
-    let events = env.events().all().filter_by_contract(endpoint);
-    let compose_sent_symbol = Symbol::new(env, "compose_sent").to_val();
-
-    // Iterate in reverse to find the most recent compose sent event
-    for event in events.events().iter().rev() {
-        let Some((topics, data)) = decode_event_topics_data(env, event) else {
-            continue;
-        };
-        if topics.contains(compose_sent_symbol) {
-            let map: Map<Symbol, Val> = data.into_val(env);
-            let from: Address = topics.get(1).unwrap().into_val(env);
-            let to: Address = topics.get(2).unwrap().into_val(env);
-            let guid: BytesN<32> = topics.get(3).unwrap().into_val(env);
-            let index: u32 = topics.get(4).unwrap().into_val(env);
-            let message: Bytes = map.get(Symbol::new(env, "message")).unwrap().into_val(env);
-
-            return Some((from, to, guid, index, message));
-        }
-    }
-
-    None
-}

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

@@ -1,62 +0,0 @@
-use soroban_sdk::{Bytes, Env, U256};
-use utils::option_ext::OptionExt;
-
-use crate::{errors::CounterError, u256_ext::U256Ext};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(u8)]
-pub enum MsgType {
-    Vanilla = 1,
-    Composed = 2,
-    #[allow(clippy::upper_case_acronyms)]
-    ABA = 3,
-    ComposedABA = 4,
-}
-
-impl From<u8> for MsgType {
-    fn from(value: u8) -> Self {
-        match value {
-            1 => MsgType::Vanilla,
-            2 => MsgType::Composed,
-            3 => MsgType::ABA,
-            4 => MsgType::ComposedABA,
-            _ => panic!("invalid msg type"),
-        }
-    }
-}
-
-pub const _MSG_TYPE_OFFSET: u8 = 0;
-pub const SRC_EID_OFFSET: u8 = 1;
-pub const VALUE_OFFSET: u8 = 5;
-
-pub fn encode(env: &Env, msg_type: MsgType, src_eid: u32) -> Bytes {
-    let msg_type: u8 = msg_type as u8;
-
-    let mut data = Bytes::new(env);
-    data.extend_from_array(&msg_type.to_be_bytes());
-    data.extend_from_array(&src_eid.to_be_bytes());
-
-    data
-}
-
-pub fn encode_with_value(env: &Env, msg_type: MsgType, src_eid: u32, value: u32) -> Bytes {
-    let mut data = encode(env, msg_type, src_eid);
-    data.append(&U256::from_u32(env, value).to_be_bytes());
-    data
-}
-
-pub fn msg_type(data: &Bytes) -> MsgType {
-    data.get(0).unwrap_or_else(|| panic!("cannot get msg type")).into()
-}
-
-pub fn src_eid(data: &Bytes) -> u32 {
-    let mut src_eid_bytes = [0u8; 4];
-    data.slice((SRC_EID_OFFSET as u32)..(VALUE_OFFSET as u32)).copy_into_slice(&mut src_eid_bytes);
-    u32::from_be_bytes(src_eid_bytes)
-}
-
-pub fn value(env: &Env, data: &Bytes) -> i128 {
-    let slice = data.slice((VALUE_OFFSET as u32)..data.len());
-    let value = if slice.is_empty() { U256::from_u32(env, 0) } else { U256::from_be_bytes(env, &slice) };
-    value.to_i128().unwrap_or_panic(env, CounterError::InvalidMsgValue)
-}

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

@@ -1,274 +0,0 @@
-use crate::{
-    codec::{self, MsgType},
-    errors::CounterError,
-    options,
-    storage::CounterStorage,
-};
-use common_macros::{contract_impl, lz_contract, only_auth};
-use endpoint_v2::{
-    ILayerZeroComposer, LayerZeroEndpointV2Client, MessagingChannelClient, MessagingComposerClient, MessagingFee,
-    Origin,
-};
-use oapp::{
-    oapp_core::{init_ownable_oapp, OAppCore},
-    oapp_receiver::{LzReceiveInternal, OAppReceiver},
-    oapp_sender::{FeePayer, OAppSenderInternal},
-};
-use oapp_macros::oapp;
-use soroban_sdk::{assert_with_error, panic_with_error, token::TokenClient, Address, Bytes, BytesN, Env};
-
-#[lz_contract]
-#[oapp(custom = [receiver])]
-pub struct Counter;
-
-#[contract_impl]
-impl Counter {
-    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Address) {
-        init_ownable_oapp::<Self>(env, owner, endpoint, delegate);
-        let endpoint_client = LayerZeroEndpointV2Client::new(env, endpoint);
-        CounterStorage::set_eid(env, &endpoint_client.eid());
-    }
-
-    pub fn quote(env: &Env, dst_eid: u32, msg_type: u32, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
-        Self::__quote(env, dst_eid, &codec::encode(env, (msg_type as u8).into(), Self::eid(env)), options, pay_in_zro)
-    }
-
-    pub fn increment(env: &Env, caller: &Address, dst_eid: u32, msg_type: u32, options: &Bytes, fee: &MessagingFee) {
-        caller.require_auth();
-
-        // Increment the outbound count
-        let outbound_count = Self::outbound_count(env, dst_eid);
-        CounterStorage::set_outbound_count(env, dst_eid, &(outbound_count + 1));
-
-        // Send the message — caller already authorized via require_auth() above
-        let message = codec::encode(env, (msg_type as u8).into(), Self::eid(env));
-        Self::__lz_send(env, dst_eid, &message, options, &FeePayer::Verified(caller.clone()), fee, caller);
-    }
-
-    // ============================================================================================
-    // Owner functions
-    // ============================================================================================
-
-    #[only_auth]
-    pub fn set_ordered_nonce(env: &Env, ordered_nonce: bool) {
-        CounterStorage::set_ordered_nonce(env, &ordered_nonce);
-    }
-
-    #[only_auth]
-    pub fn skip_inbound_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>, nonce: u64) {
-        let contract_address = env.current_contract_address();
-
-        let endpoint_address = Self::endpoint(env);
-        let endpoint = MessagingChannelClient::new(env, &endpoint_address);
-        endpoint.skip(&contract_address, &contract_address, &src_eid, sender, &nonce);
-
-        if CounterStorage::ordered_nonce(env) {
-            let max_received_nonce = CounterStorage::max_received_nonce(env, src_eid, sender);
-            CounterStorage::set_max_received_nonce(env, src_eid, sender, &(max_received_nonce + 1));
-        }
-    }
-
-    #[only_auth]
-    pub fn withdraw(env: &Env, to: &Address, amount: i128) {
-        let native_token = LayerZeroEndpointV2Client::new(env, &Self::endpoint(env)).native_token();
-        TokenClient::new(env, &native_token).transfer(&env.current_contract_address(), to, &amount);
-    }
-
-    // ============================================================================================
-    // View functions
-    // ============================================================================================
-
-    pub fn eid(env: &Env) -> u32 {
-        CounterStorage::eid(env).unwrap()
-    }
-
-    pub fn count(env: &Env) -> u64 {
-        CounterStorage::count(env)
-    }
-
-    pub fn composed_count(env: &Env) -> u64 {
-        CounterStorage::composed_count(env)
-    }
-
-    pub fn inbound_count(env: &Env, eid: u32) -> u64 {
-        CounterStorage::inbound_count(env, eid)
-    }
-
-    pub fn outbound_count(env: &Env, eid: u32) -> u64 {
-        CounterStorage::outbound_count(env, eid)
-    }
-
-    // ============================================================================================
-    // Internal Functions
-    // ============================================================================================
-
-    fn __accept_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>, nonce: u64) {
-        let current_nonce = CounterStorage::max_received_nonce(env, src_eid, sender);
-        if CounterStorage::ordered_nonce(env) {
-            assert_with_error!(env, nonce == current_nonce + 1, CounterError::OAppInvalidNonce);
-        }
-        // Update the max nonce anyway. once the ordered mode is turned on, missing early nonces will be rejected
-        if nonce > current_nonce {
-            CounterStorage::set_max_received_nonce(env, src_eid, sender, &nonce);
-        }
-    }
-}
-
-// ============================================================================================
-// LzReceiveInternal implementation
-// ============================================================================================
-
-impl LzReceiveInternal for Counter {
-    fn __lz_receive(
-        env: &Env,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        _extra_data: &Bytes,
-        _executor: &Address,
-        value: i128,
-    ) {
-        // handle the message
-        Self::__accept_nonce(env, origin.src_eid, &origin.sender, origin.nonce);
-
-        let contract_address = env.current_contract_address();
-
-        // Increment the count and inbound count
-        let count = Self::count(env);
-        let inbound_count = Self::inbound_count(env, origin.src_eid);
-        CounterStorage::set_count(env, &(count + 1));
-        CounterStorage::set_inbound_count(env, origin.src_eid, &(inbound_count + 1));
-
-        let assert_received_value = || {
-            let expected_msg_value = codec::value(env, message);
-            assert_with_error!(env, value >= expected_msg_value, CounterError::InsufficientValue);
-        };
-
-        match codec::msg_type(message) {
-            MsgType::Vanilla => {
-                assert_received_value();
-            }
-            MsgType::Composed | MsgType::ComposedABA => {
-                let endpoint: MessagingComposerClient<'_> = MessagingComposerClient::new(env, &Self::endpoint(env));
-                endpoint.send_compose(&contract_address, &contract_address, guid, &0, message);
-            }
-            MsgType::ABA => {
-                assert_received_value();
-
-                // Increment the outbound count
-                let outbound_count = Self::outbound_count(env, origin.src_eid);
-                CounterStorage::set_outbound_count(env, origin.src_eid, &(outbound_count + 1));
-
-                // Send the response message — contract is the fee payer (auto-authorized)
-                let options = options::executor_lz_receive_option(env, 200000, 10);
-                Self::__lz_send(
-                    env,
-                    origin.src_eid,
-                    &codec::encode_with_value(env, MsgType::Vanilla, Self::eid(env), 10),
-                    &options,
-                    &FeePayer::Verified(contract_address.clone()),
-                    &MessagingFee { native_fee: value, zro_fee: 0 },
-                    &contract_address,
-                );
-            }
-        }
-    }
-}
-
-// ============================================================================================
-// Custom OAppReceiver implementation
-// ============================================================================================
-
-#[contract_impl(contracttrait)]
-impl OAppReceiver for Counter {
-    fn next_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>) -> u64 {
-        if CounterStorage::ordered_nonce(env) {
-            CounterStorage::max_received_nonce(env, src_eid, sender) + 1
-        } else {
-            0
-        }
-    }
-}
-
-// ============================================================================================
-// ILayerZeroComposer implementation
-// ============================================================================================
-
-#[contract_impl]
-impl ILayerZeroComposer for Counter {
-    fn lz_compose(
-        env: &Env,
-        executor: &Address,
-        from: &Address,
-        guid: &BytesN<32>,
-        index: u32,
-        message: &Bytes,
-        _extra_data: &Bytes,
-        value: i128,
-    ) {
-        // Clear compose message, transfer value, and require executor auth
-        clear_compose_and_transfer::<Self>(env, executor, from, guid, index, message, value);
-
-        let msg_type = codec::msg_type(message);
-        if msg_type != MsgType::Composed && msg_type != MsgType::ComposedABA {
-            panic_with_error!(env, CounterError::InvalidMsgType);
-        }
-
-        // Assert the value is sufficient
-        let expected_msg_value = codec::value(env, message);
-        assert_with_error!(env, value >= expected_msg_value, CounterError::InsufficientValue);
-
-        // Increment the composed count
-        CounterStorage::set_composed_count(env, &(Self::composed_count(env) + 1));
-
-        // Handle ComposedABA: send response message back to source
-        if msg_type == MsgType::ComposedABA {
-            let src_eid = codec::src_eid(message);
-
-            // Increment the outbound count
-            CounterStorage::set_outbound_count(env, src_eid, &(Self::outbound_count(env, src_eid) + 1));
-
-            // Send the response message — contract is the fee payer (auto-authorized)
-            let curr_address = env.current_contract_address();
-            Self::__lz_send(
-                env,
-                src_eid,
-                &codec::encode(env, MsgType::Vanilla, Self::eid(env)),
-                &options::executor_lz_receive_option(env, 200000, 0),
-                &FeePayer::Verified(curr_address.clone()),
-                &MessagingFee { native_fee: value, zro_fee: 0 },
-                &curr_address,
-            );
-        }
-    }
-}
-
-/// Clears a compose message and transfers native token value from executor to the OApp.
-///
-/// This helper handles the common pattern in `lz_compose` implementations:
-/// 1. Requires executor authorization
-/// 2. Clears the compose message from the endpoint
-/// 3. Transfers native token from executor to OApp if value > 0
-pub fn clear_compose_and_transfer<T: OAppCore>(
-    env: &Env,
-    executor: &Address,
-    from: &Address,
-    guid: &BytesN<32>,
-    index: u32,
-    message: &Bytes,
-    value: i128,
-) {
-    executor.require_auth();
-
-    let curr_address = env.current_contract_address();
-    let endpoint = T::endpoint(env);
-
-    // Clear the compose message
-    MessagingComposerClient::new(env, &endpoint).clear_compose(&curr_address, from, guid, &index, message);
-
-    // Transfer value from executor to current contract
-    if value > 0 {
-        let native_token = LayerZeroEndpointV2Client::new(env, &endpoint).native_token();
-        TokenClient::new(env, &native_token).transfer(executor, &curr_address, &value);
-    }
-}

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

@@ -1,9 +0,0 @@
-use common_macros::contract_error;
-
-#[contract_error]
-pub enum CounterError {
-    OAppInvalidNonce,
-    InvalidMsgValue,
-    InsufficientValue,
-    InvalidMsgType,
-}

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

@@ -1,16 +0,0 @@
-#![no_std]
-
-mod codec;
-pub mod errors;
-mod options;
-mod storage;
-mod u256_ext;
-
-pub mod counter;
-
-#[cfg(test)]
-#[path = "../integration_tests/mod.rs"]
-mod integration_tests;
-
-#[cfg(test)]
-mod tests;

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

@@ -1,30 +0,0 @@
-use soroban_sdk::{Bytes, Env};
-
-pub const EXECUTOR_ID: u8 = 1; // WORKER_ID
-
-pub const LZ_RECEIVE_TYPE: u8 = 1; // OPTION_TYPE
-
-// copied from solana's counter options.rs
-pub fn executor_lz_receive_option(env: &Env, gas_limit: u128, value: u128) -> Bytes {
-    let mut options = Bytes::new(env);
-
-    options.extend_from_slice(&3u16.to_be_bytes());
-
-    options.push_back(EXECUTOR_ID);
-
-    let gas_limit_bytes = gas_limit.to_be_bytes();
-    let value_bytes = value.to_be_bytes();
-
-    if value == 0 {
-        options.extend_from_slice(&(gas_limit_bytes.len() as u16 + 1).to_be_bytes());
-        options.push_back(LZ_RECEIVE_TYPE);
-        options.extend_from_slice(&gas_limit_bytes);
-    } else {
-        options.extend_from_slice(&((gas_limit_bytes.len() + value_bytes.len()) as u16 + 1).to_be_bytes());
-        options.push_back(LZ_RECEIVE_TYPE);
-        options.extend_from_slice(&gas_limit_bytes);
-        options.extend_from_slice(&value_bytes);
-    }
-
-    options
-}