@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

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

@@ -1,16 +1,30 @@
-use crate::{
-    codec::MsgType,
-    integration_tests::setup::{decode_packet, ChainSetup},
-};
-use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
+//! 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,
+    Address, Bytes, BytesN, Env, IntoVal, Map, Symbol, Val, Vec,
 };
+use utils::buffer_reader::BufferReader;
+
+/// 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;
+}
 
-/// Helper to extract BytesN<32> payload from an Address
+/// 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,
@@ -18,13 +32,76 @@ pub fn address_to_bytes32(address: &Address) -> BytesN<32> {
     }
 }
 
-pub fn quote(chain: &ChainSetup<'_>, dst_eid: u32, msg_type: MsgType, options: &Bytes) -> MessagingFee {
-    chain.counter.quote(&dst_eid, &(msg_type as u32), options, &false)
+/// 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).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    counter.set_peer(&dst_eid, &peer_option);
+}
+
+/// 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(
+pub fn increment<'a, C: ChainSetupCommon<'a>>(
     env: &Env,
-    chain: &ChainSetup<'_>,
+    chain: &C,
     sender: &Address,
     dst_eid: u32,
     msg_type: MsgType,
@@ -35,87 +112,89 @@ pub fn increment(
     env.mock_auths(&[MockAuth {
         address: sender,
         invoke: &MockAuthInvoke {
-            contract: &chain.counter.address,
+            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,
+                contract: chain.native_token(),
                 fn_name: "transfer",
-                args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
+                args: (sender, &chain.endpoint().address, &fee.native_fee).into_val(env),
                 sub_invokes: &[],
             }],
         },
     }]);
-    chain.counter.increment(sender, &dst_eid, &msg_type, options, fee);
+    chain.counter().increment(sender, &dst_eid, &msg_type, options, fee);
 }
 
-pub fn validate_packet(env: &Env, chain: &ChainSetup<'_>, packet_event: &(Bytes, Bytes, Address)) {
-    let packet = decode_packet(env, &packet_event.0);
-    let encoded_header = packet_codec_v1::encode_packet_header(env, &packet);
-    let payload_hash = packet_codec_v1::payload_hash(env, &packet);
-
-    env.mock_auths(&[MockAuth {
-        address: &chain.owner,
-        invoke: &MockAuthInvoke {
-            contract: &chain.sml.address,
-            fn_name: "validate_packet",
-            args: (&encoded_header, &payload_hash).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    chain.sml.validate_packet(&encoded_header, &payload_hash);
-}
-
-pub fn lz_receive(
+/// 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: &ChainSetup<'_>,
+    chain: &C,
     executor: &Address,
     packet: &OutboundPacket,
     value: i128,
-    _aba: bool,
 ) {
+    // 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,
+        contract: chain.native_token(),
         fn_name: "transfer",
-        args: (executor, &chain.counter.address, &value).into_val(env),
+        args: (executor, &chain.counter().address, &value).into_val(env),
         sub_invokes: &[],
     }];
 
     env.mock_auths(&[MockAuth {
         address: executor,
         invoke: &MockAuthInvoke {
-            contract: &chain.counter.address,
+            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);
+    chain.counter().lz_receive(executor, &origin, &packet.guid, &packet.message, &Bytes::new(env), &value);
 }
 
-pub fn lz_compose(env: &Env, chain: &ChainSetup<'_>, executor: &Address, packet: &OutboundPacket, value: i128) {
+/// 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_from",
-        args: (executor, executor, &chain.counter.address, &value).into_val(env),
+        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,
+            contract: &chain.counter().address,
             fn_name: "lz_compose",
-            args: (executor, &chain.counter.address, &packet.guid, &0_u32, &packet.message, &Bytes::new(env), &value)
+            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(
+    chain.counter().lz_compose(
         executor,
-        &chain.counter.address,
+        &chain.counter().address,
         &packet.guid,
         &0,
         &packet.message,
@@ -124,11 +203,24 @@ pub fn lz_compose(env: &Env, chain: &ChainSetup<'_>, executor: &Address, packet:
     );
 }
 
-// returns (encoded_payload, options, send_library)
+/// 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 mut packet = None;
-    for (emitter, topics, data) in env.events().all() {
-        let packet_sent_symbol = Symbol::new(env, "packet_sent").to_val();
+    let events = env.events().all();
+    let packet_sent_symbol = Symbol::new(env, "packet_sent").to_val();
+
+    // Iterate in reverse to find the most recent packet sent event
+    for i in (0..events.len()).rev() {
+        let (emitter, topics, data) = events.get(i).unwrap();
         if emitter == *endpoint && topics.contains(packet_sent_symbol) {
             let map: Map<Symbol, Val> = data.into_val(env);
 
@@ -136,9 +228,60 @@ pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, B
             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);
 
-            packet = Some((encoded_payload, options, send_library));
+            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();
+    let packet_sent_symbol = Symbol::new(env, "packet_sent").to_val();
+    let mut result = Vec::new(env);
+
+    for i in 0..events.len() {
+        let (emitter, topics, data) = events.get(i).unwrap();
+        if emitter == *endpoint && 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();
+    let compose_sent_symbol = Symbol::new(env, "compose_sent").to_val();
+
+    // Iterate in reverse to find the most recent compose sent event
+    for i in (0..events.len()).rev() {
+        let (emitter, topics, data) = events.get(i).unwrap();
+        if emitter == *endpoint && 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));
         }
     }
 
-    packet
+    None
 }

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

@@ -4,34 +4,32 @@ use crate::{
     options,
     storage::CounterStorage,
 };
-use common_macros::{contract_impl, only_owner};
+use common_macros::{contract_impl, only_auth};
 use endpoint_v2::{
     ILayerZeroComposer, LayerZeroEndpointV2Client, MessagingChannelClient, MessagingComposerClient, MessagingFee,
     Origin,
 };
 use oapp::{
-    oapp_core::{oapp_initialize, OAppCore},
-    oapp_receiver::{self, OAppReceiver},
-    oapp_sender::OAppSender,
+    oapp_core::{initialize_oapp, OAppCore},
+    oapp_receiver::{LzReceiveInternal, OAppReceiver},
+    oapp_sender::OAppSenderInternal,
 };
-use oapp_macros::{oapp, oapp_manual_impl};
+use oapp_macros::oapp;
 use soroban_sdk::{assert_with_error, panic_with_error, token::TokenClient, Address, Bytes, BytesN, Env};
-use utils::ownable::Ownable;
 
-#[oapp]
-#[oapp_manual_impl(receiver)]
+#[oapp(custom = [receiver])]
 pub struct Counter;
 
 #[contract_impl]
 impl Counter {
     pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Address) {
-        oapp_initialize::<Self>(env, owner, endpoint, &Some(delegate.clone()));
+        initialize_oapp::<Self>(env, owner, endpoint, &Some(delegate.clone()));
         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::lz_quote(env, dst_eid, &codec::encode(env, (msg_type as u8).into(), Self::eid(env)), options, pay_in_zro)
+        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) {
@@ -43,19 +41,19 @@ impl Counter {
 
         // Send the message
         let message = codec::encode(env, (msg_type as u8).into(), Self::eid(env));
-        Self::lz_send(env, caller, dst_eid, &message, options, fee, caller);
+        Self::__lz_send(env, dst_eid, &message, options, caller, fee, caller);
     }
 
     // ============================================================================================
     // Owner functions
     // ============================================================================================
 
-    #[only_owner]
+    #[only_auth]
     pub fn set_ordered_nonce(env: &Env, ordered_nonce: bool) {
         CounterStorage::set_ordered_nonce(env, &ordered_nonce);
     }
 
-    #[only_owner]
+    #[only_auth]
     pub fn skip_inbound_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>, nonce: u64) {
         let contract_address = env.current_contract_address();
 
@@ -110,30 +108,19 @@ impl Counter {
 }
 
 // ============================================================================================
-// OAppReceiver implementation
+// LzReceiveInternal 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
-        }
-    }
-
-    fn lz_receive(
+impl LzReceiveInternal for Counter {
+    fn __lz_receive(
         env: &Env,
-        executor: &Address,
         origin: &Origin,
         guid: &BytesN<32>,
         message: &Bytes,
         _extra_data: &Bytes,
+        _executor: &Address,
         value: i128,
     ) {
-        oapp_receiver::verify_and_clear_payload::<Self>(env, executor, origin, guid, message, value);
-
         // handle the message
         Self::__accept_nonce(env, origin.src_eid, &origin.sender, origin.nonce);
 
@@ -167,12 +154,12 @@ impl OAppReceiver for Counter {
 
                 // Send the response message
                 let options = options::executor_lz_receive_option(env, 200000, 10);
-                Self::lz_send(
+                Self::__lz_send(
                     env,
-                    &contract_address,
                     origin.src_eid,
                     &codec::encode_with_value(env, MsgType::Vanilla, Self::eid(env), 10),
                     &options,
+                    &contract_address,
                     &MessagingFee { native_fee: value, zro_fee: 0 },
                     &contract_address,
                 );
@@ -181,6 +168,21 @@ impl OAppReceiver for Counter {
     }
 }
 
+// ============================================================================================
+// 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
 // ============================================================================================
@@ -197,28 +199,18 @@ impl ILayerZeroComposer for Counter {
         _extra_data: &Bytes,
         value: i128,
     ) {
-        executor.require_auth();
+        // 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);
         }
 
-        let curr_address = env.current_contract_address();
-        let endpoint_address = Self::endpoint(env);
-
-        // Transfer value from executor to current contract
-        if value > 0 {
-            let native_token = LayerZeroEndpointV2Client::new(env, &endpoint_address).native_token();
-            TokenClient::new(env, &native_token).transfer_from(executor, executor, &curr_address, &value);
-        }
         // Assert the value is sufficient
         let expected_msg_value = codec::value(env, message);
         assert_with_error!(env, value >= expected_msg_value, CounterError::InsufficientValue);
 
-        // Clear the compose message
-        MessagingComposerClient::new(env, &endpoint_address).clear_compose(&curr_address, from, guid, &index, message);
-
         // Increment the composed count
         CounterStorage::set_composed_count(env, &(Self::composed_count(env) + 1));
 
@@ -230,15 +222,46 @@ impl ILayerZeroComposer for Counter {
             CounterStorage::set_outbound_count(env, src_eid, &(Self::outbound_count(env, src_eid) + 1));
 
             // Send the response message
-            Self::lz_send(
+            let curr_address = env.current_contract_address();
+            Self::__lz_send(
                 env,
-                &curr_address,
                 src_eid,
                 &codec::encode(env, MsgType::Vanilla, Self::eid(env)),
                 &options::executor_lz_receive_option(env, 200000, 0),
+                &curr_address,
                 &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/tests/mod.rs

@@ -22,16 +22,3 @@ pub fn mint_to(env: &Env, owner: &Address, native_token: &Address, to: &Address,
     sac.mint(to, &amount);
 }
 
-pub fn approve(env: &Env, from: &Address, native_token: &Address, amount: i128) {
-    env.mock_auths(&[MockAuth {
-        address: from,
-        invoke: &MockAuthInvoke {
-            contract: native_token,
-            fn_name: "approve",
-            args: (from, from, amount, 10_u32).into_val(env),
-            sub_invokes: &[],
-        },
-    }]);
-    let sac = StellarAssetClient::new(env, native_token);
-    sac.approve(from, from, &amount, &10_u32);
-}

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

@@ -11,7 +11,7 @@ use crate::{
     codec::{self, MsgType},
     counter::{Counter, CounterClient},
     errors::CounterError,
-    tests::{approve, mint_to},
+    tests::mint_to,
 };
 
 struct TestSetup<'a> {
@@ -252,11 +252,10 @@ fn test_lz_compose() {
     let extra_data = Bytes::new(&env);
 
     mint_to(&env, &owner, &native_token, &executor, value as i128);
-    approve(&env, &executor, &native_token, value as i128);
     let sub_invokes_with_transfer = MockAuthInvoke {
         contract: &native_token,
-        fn_name: "transfer_from",
-        args: (&executor, &executor, &counter.address, &(value as i128)).into_val(&env),
+        fn_name: "transfer",
+        args: (&executor, &counter.address, &(value as i128)).into_val(&env),
         sub_invokes: &[],
     };
     env.mock_auths(&[MockAuth {
@@ -304,11 +303,10 @@ fn test_lz_compose_aba() {
 
     setup_mock_peer(&env, &owner, &counter, origin.src_eid);
     mint_to(&env, &owner, &native_token, &executor, value as i128);
-    approve(&env, &executor, &native_token, value as i128);
     let sub_invokes_with_transfer = MockAuthInvoke {
         contract: &native_token,
-        fn_name: "transfer_from",
-        args: (&executor, &executor, &counter.address, &(value as i128)).into_val(&env),
+        fn_name: "transfer",
+        args: (&executor, &counter.address, &(value as i128)).into_val(&env),
         sub_invokes: &[],
     };
     env.mock_auths(&[MockAuth {

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

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