@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

package/contracts/oapps/{oft-std → oft-core}/integration-tests/setup.rs

@@ -1,37 +1,139 @@
-//! Integration test setup for OFT-STD with real EndpointV2 and SimpleMessageLib.
+//! Integration test setup for OFT.
 //!
-//! This file contains test setup utilities for OFT-STD with all extensions enabled.
+//! This file contains TestOFT contract and test setup utilities.
 
-extern crate self as oft_std;
 extern crate std;
 
-use crate::integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address};
-use crate::oft::{OFTMode, OFTStd, OFTStdClient};
-use endpoint_v2::{EndpointV2, EndpointV2Client};
+use crate::{
+    self as oft_core,
+    integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address},
+    oft_core::{initialize_oft, lz_receive, OFTClient, OFTCore, OFTInternal},
+    storage::OFTStorage,
+    types::OFTReceipt,
+};
+use common_macros::contract_impl;
+use endpoint_v2::{EndpointV2, EndpointV2Client, ILayerZeroComposer, Origin};
+use oapp::oapp_receiver::LzReceiveInternal;
 use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
 use soroban_sdk::{
-    contract, contractimpl, log,
+    contract, contractimpl, contracttype, log, symbol_short,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
-    token::TokenClient,
-    Address, BytesN, Env, IntoVal,
+    token::{StellarAssetClient, TokenClient},
+    Address, Bytes, BytesN, Env, IntoVal,
 };
 
 // ============================================================================
-// Dummy Recipient - used to create valid contract addresses for recipients
+// Test OFT Contract
+// ============================================================================
+
+#[oapp_macros::oapp]
+pub struct TestOFT;
+
+impl LzReceiveInternal for TestOFT {
+    fn __lz_receive(
+        env: &Env,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        extra_data: &Bytes,
+        executor: &Address,
+        value: i128,
+    ) {
+        lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+    }
+}
+
+#[contract_impl]
+impl TestOFT {
+    pub fn __constructor(
+        env: &Env,
+        token: &Address,
+        owner: &Address,
+        endpoint: &Address,
+        delegate: &Option<Address>,
+        shared_decimals: u32,
+    ) {
+        initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OFTCore for TestOFT {}
+
+impl OFTInternal for TestOFT {
+    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        // Get the receipt (handles decimal conversion, fees, etc.)
+        let receipt = Self::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
+        // Actually burn tokens from sender
+        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).burn(sender, &receipt.amount_sent_ld);
+        receipt
+    }
+
+    fn __credit(env: &Env, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
+        // Actually mint tokens to recipient
+        StellarAssetClient::new(env, &OFTStorage::token(env).unwrap()).mint(to, &amount_ld);
+        amount_ld
+    }
+}
+
+// ============================================================================
+// Dummy Composer for testing compose messages
 // ============================================================================
 
+#[contracttype]
+pub struct ComposeMessage {
+    pub executor: Address,
+    pub from: Address,
+    pub guid: BytesN<32>,
+    pub index: u32,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub value: i128,
+}
+
 #[contract]
-pub struct DummyRecipient;
+pub struct DummyComposer;
 
-#[contractimpl]
-impl DummyRecipient {
-    pub fn __constructor(_env: &Env) {}
+#[contract_impl]
+impl DummyComposer {
+    pub fn __constructor(env: &Env, endpoint: &Address) {
+        env.storage().instance().set(&symbol_short!("endpoint"), endpoint);
+    }
+
+    pub fn compose_message(env: &Env) -> Option<ComposeMessage> {
+        env.storage().instance().get(&symbol_short!("msg"))
+    }
 }
 
-/// Creates a valid recipient address by deploying a dummy contract.
-/// Use this in tests when the address needs to pass the `.exists()` check.
-pub fn create_recipient_address(env: &Env) -> Address {
-    env.register(DummyRecipient, ())
+#[contract_impl]
+impl ILayerZeroComposer for DummyComposer {
+    fn lz_compose(
+        env: &Env,
+        executor: &Address,
+        from: &Address,
+        guid: &BytesN<32>,
+        index: u32,
+        message: &Bytes,
+        extra_data: &Bytes,
+        value: i128,
+    ) {
+        let endpoint_address: Address = env.storage().instance().get(&symbol_short!("endpoint")).unwrap();
+        let endpoint = endpoint_v2::MessagingComposerClient::new(env, &endpoint_address);
+        endpoint.clear_compose(&env.current_contract_address(), from, guid, &index, message);
+
+        env.storage().instance().set(
+            &symbol_short!("msg"),
+            &ComposeMessage {
+                executor: executor.clone(),
+                from: from.clone(),
+                guid: guid.clone(),
+                index,
+                message: message.clone(),
+                extra_data: extra_data.clone(),
+                value,
+            },
+        );
+    }
 }
 
 // ============================================================================
@@ -42,16 +144,16 @@ pub struct ChainSetup<'a> {
     pub eid: u32,
     pub owner: Address,
     pub native_token: Address,
-    pub zro_token: Address,
     pub oft_token: Address,
     pub endpoint: EndpointV2Client<'a>,
     pub sml: SimpleMessageLibClient<'a>,
-    pub oft: OFTStdClient<'a>,
-    pub fee_collector: Address,
+    pub oft: OFTClient<'a>,
+    pub composer: DummyComposerClient<'a>,
 }
 
 pub struct TestSetup<'a> {
     pub env: Env,
+
     pub chain_a: ChainSetup<'a>,
     pub chain_b: ChainSetup<'a>,
 }
@@ -59,13 +161,9 @@ pub struct TestSetup<'a> {
 fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let owner = Address::generate(env);
 
-    // Create native token FIRST - this must match the endpoint's NATIVE_TOKEN constant
     let sac = env.register_stellar_asset_contract_v2(owner.clone());
     let native_token = sac.address();
 
-    // Generate fee_collector AFTER native_token to not affect the address derivation
-    let fee_collector = Address::generate(env);
-
     // Create ZRO token
     let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let zro_token = zro_sac.address();
@@ -79,12 +177,13 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let sml_address = env.register(SimpleMessageLib, (&owner, &endpoint_address, &fee_recipient));
     let delegate: Option<Address> = Some(owner.clone());
     let shared_decimals: u32 = 6; // Default shared decimals
-    let mode = OFTMode::MintBurn;
-    let oft_address = env.register(OFTStd, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals, &mode));
+    let oft_address = env.register(TestOFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals));
+    let composer_address = env.register(DummyComposer, (&endpoint_address,));
 
     let endpoint = EndpointV2Client::new(env, &endpoint_address);
     let sml = SimpleMessageLibClient::new(env, &sml_address);
-    let oft = OFTStdClient::new(env, &oft_address);
+    let oft = OFTClient::new(env, &oft_address);
+    let composer = DummyComposerClient::new(env, &composer_address);
 
     // Set ZRO token in endpoint
     env.mock_auths(&[MockAuth {
@@ -101,7 +200,7 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     register_library(env, &owner, &endpoint, &sml.address);
 
     let eid = endpoint.eid();
-    ChainSetup { eid, owner, native_token, zro_token, oft_token, endpoint, sml, oft, fee_collector }
+    ChainSetup { eid, owner, native_token, oft_token, endpoint, sml, oft, composer }
 }
 
 pub fn setup<'a>() -> TestSetup<'a> {
@@ -158,7 +257,7 @@ pub fn wire_oft(env: &Env, chains: &[&ChainSetup<'_>]) {
     }
 }
 
-pub fn set_peer(env: &Env, owner: &Address, oft: &OFTStdClient<'_>, dst_eid: u32, peer: &BytesN<32>) {
+pub fn set_peer(env: &Env, owner: &Address, oft: &OFTClient<'_>, dst_eid: u32, peer: &BytesN<32>) {
     env.mock_auths(&[MockAuth {
         address: owner,
         invoke: &MockAuthInvoke {

package/contracts/oapps/{oft → oft-core}/integration-tests/test_with_sml.rs

@@ -13,7 +13,7 @@ use crate::{
     },
     tests::test_utils::create_recipient_address,
     types::SendParam,
-    utils::address_to_bytes32,
+    utils::address_payload,
 };
 
 #[test]
@@ -43,7 +43,7 @@ fn test_send_vanilla() {
 
     let send_param = SendParam {
         dst_eid: chain_b.eid,
-        to: address_to_bytes32(&receiver),
+        to: address_payload(&receiver),
         amount_ld: 10e7 as i128,
         min_amount_ld: 10e7 as i128,
         extra_options: bytes!(&env),
@@ -99,7 +99,7 @@ fn test_send_composed() {
 
     let send_param = SendParam {
         dst_eid: chain_b.eid,
-        to: address_to_bytes32(&receiver),
+        to: address_payload(&receiver),
         amount_ld: 10e7 as i128,
         min_amount_ld: 10e7 as i128,
         extra_options: bytes!(&env),

package/contracts/oapps/oft-core/integration-tests/utils.rs

@@ -0,0 +1,201 @@
+use core::ops::Mul;
+
+use crate::{
+    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec},
+    integration_tests::setup::{decode_packet, ChainSetup},
+    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
+};
+use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
+use message_lib_common::packet_codec_v1;
+use soroban_sdk::{
+    address_payload::AddressPayload,
+    testutils::{Events, MockAuth, MockAuthInvoke},
+    token::StellarAssetClient,
+    xdr::ToXdr,
+    Address, Bytes, BytesN, Env, IntoVal, Map, Symbol, Val, Vec,
+};
+
+pub fn address_to_peer_bytes32(address: &Address) -> BytesN<32> {
+    match address.to_payload().unwrap() {
+        AddressPayload::ContractIdHash(payload) => payload,
+        AddressPayload::AccountIdPublicKeyEd25519(_) => panic!("peer must be a contract"),
+    }
+}
+
+pub fn peer_bytes32_to_address(env: &Env, bytes32: &BytesN<32>) -> Address {
+    AddressPayload::ContractIdHash(bytes32.clone()).to_address(env)
+}
+
+pub fn quote_oft(chain: &ChainSetup<'_>, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
+    chain.oft.quote_oft(send_param)
+}
+
+pub fn quote_send(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    pay_in_zro: bool,
+) -> MessagingFee {
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "quote_send",
+            args: (sender, send_param, &pay_in_zro).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.quote_send(sender, send_param, &pay_in_zro)
+}
+
+pub fn send(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    oft_receipt: &OFTReceipt,
+) {
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "send",
+            args: (sender, send_param, fee, refund_address).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: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "burn",
+                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+                    sub_invokes: &[],
+                },
+            ],
+        },
+    }]);
+    chain.oft.send(sender, send_param, fee, refund_address);
+}
+
+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(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    executor: &Address,
+    packet: &OutboundPacket,
+    recipient: &Address,
+    value: i128,
+) {
+    let origin =
+        Origin { src_eid: packet.src_eid, sender: address_to_peer_bytes32(&packet.sender), nonce: packet.nonce };
+    let extra_options = recipient.to_xdr(env);
+
+    env.mock_auths(&[MockAuth {
+        address: executor,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "lz_receive",
+            args: (executor, &origin, &packet.guid, &packet.message, &extra_options, &value).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_v2::LayerZeroReceiverClient::new(env, &chain.oft.address).lz_receive(
+        executor,
+        &origin,
+        &packet.guid,
+        &packet.message,
+        &extra_options,
+        &value,
+    );
+}
+
+pub fn lz_compose(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    executor: &Address,
+    packet: &OutboundPacket,
+    index: u32,
+    extra_data: &Bytes,
+    value: i128,
+) {
+    let oft_msg = oft_msg_codec::OFTMessage::decode(&packet.message);
+    let oft_compose_msg = OFTComposeMsg {
+        nonce: packet.nonce,
+        src_eid: packet.src_eid,
+        amount_ld: (oft_msg.amount_sd as i128).mul(chain.oft.decimal_conversion_rate()),
+        compose_from: oft_msg.compose_from.unwrap(),
+        compose_msg: oft_msg.compose_msg.unwrap(),
+    }
+    .encode(&env);
+
+    chain.composer.lz_compose(executor, &chain.oft.address, &packet.guid, &index, &oft_compose_msg, extra_data, &value);
+}
+
+// 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();
+        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);
+
+            packet = Some((encoded_payload, options, send_library));
+        }
+    }
+
+    packet
+}
+
+pub fn mint_to(env: &Env, owner: &Address, token: &Address, to: &Address, amount: i128) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: token,
+            fn_name: "mint",
+            args: (to, amount).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let sac = StellarAssetClient::new(env, token);
+    sac.mint(to, &amount);
+}
+
+pub fn transfer_sac_admin(env: &Env, owner: &Address, token: &Address, new_admin: &Address) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: token,
+            fn_name: "set_admin",
+            args: (new_admin,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    StellarAssetClient::new(env, token).set_admin(new_admin);
+}

package/contracts/oapps/oft-core/src/errors.rs

@@ -0,0 +1,13 @@
+use common_macros::contract_error;
+
+// OFT library error codes: 3000-3099
+// See ERROR_SPEC.md for allocation rules
+
+/// OFTError: 3000-3099
+#[contract_error]
+pub enum OFTError {
+    InvalidLocalDecimals = 3000,
+    NotInitialized,
+    Overflow,
+    SlippageExceeded,
+}

package/contracts/oapps/oft-core/src/lib.rs

@@ -0,0 +1,18 @@
+#![no_std]
+
+pub mod codec;
+pub mod errors;
+pub mod events;
+pub mod oft_core;
+pub mod storage;
+pub mod types;
+pub mod utils;
+
+pub use oft_core::*;
+
+#[cfg(test)]
+#[path = "../integration-tests/mod.rs"]
+pub mod integration_tests;
+
+#[cfg(test)]
+pub mod tests;