@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.19

package/Cargo.lock

@@ -1199,31 +1199,32 @@ version = "0.0.1"
 name = "oft"
 version = "0.0.1"
 dependencies = [
+ "cfg-if",
  "common-macros",
  "endpoint-v2",
- "insta",
  "message-lib-common",
  "oapp",
  "oapp-macros",
+ "oft-core",
  "simple-message-lib",
  "soroban-sdk",
- "stellar-macros",
- "stellar-tokens",
  "utils",
 ]
 
 [[package]]
-name = "oft-std"
+name = "oft-core"
 version = "0.0.1"
 dependencies = [
  "common-macros",
  "endpoint-v2",
+ "insta",
  "message-lib-common",
  "oapp",
  "oapp-macros",
- "oft",
  "simple-message-lib",
  "soroban-sdk",
+ "stellar-macros",
+ "stellar-tokens",
  "utils",
 ]
 
@@ -2094,6 +2095,8 @@ name = "ts-bindings-gen"
 version = "0.0.1"
 dependencies = [
  "anyhow",
+ "base64 0.22.1",
+ "sha2 0.10.9",
  "soroban-spec-typescript",
 ]
 

package/Cargo.toml

@@ -33,7 +33,7 @@ executor-fee-lib = { path = "contracts/workers/executor-fee-lib" }
 dvn = { path = "contracts/workers/dvn" }
 dvn-fee-lib = { path = "contracts/workers/dvn-fee-lib" }
 price-feed = { path = "contracts/workers/price-feed" }
-oft = { path = "contracts/oapps/oft" }
+oft-core = { path = "contracts/oapps/oft-core" }
 stellar-macros = { git = "https://github.com/OpenZeppelin/stellar-contracts.git", tag = "v0.5.1" }
 stellar-tokens = { git = "https://github.com/OpenZeppelin/stellar-contracts.git", tag = "v0.5.1" }
 stellar-contract-utils = { git = "https://github.com/OpenZeppelin/stellar-contracts.git", tag = "v0.5.1" }

package/contracts/ERROR_SPEC.md

@@ -38,7 +38,7 @@ Each library has a unique error code range to:
 | 1300 - 1999 | Protocol Lib    | (reserved)         | Future protocol libs                                         |
 | 2000 - 2099 | OApp Lib        | oapp               | `oapps/oapp/src/errors.rs`                                   |
 | 2100 - 2999 | OApp Lib        | (reserved)         | Future OApp libs                                             |
-| 3000 - 3099 | OFT Lib         | oft                | `oapps/oft/src/errors.rs`                                    |
+| 3000 - 3099 | OFT Lib         | oft-core           | `oapps/oft-core/src/errors.rs`                               |
 | 3100 - 3999 | OFT Lib         | (reserved)         | Future OFT libs                                              |
 
 ---

package/contracts/message-libs/uln-302/src/send_uln.rs

@@ -86,7 +86,7 @@ impl ISendLib for Uln302 {
 
         // Handle ZRO fee recipients
         let mut zro_fee_recipients = vec![env];
-        if treasury_fee > 0 {
+        if treasury_fee != 0 {
             // The treasury contract address is used as the fixed fee recipient (rather than allowing
             // the treasury admin to configure a custom receiver). This is because ZRO may be issued
             // as a Stellar Classic Asset, which requires the recipient to have an established trustline.

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

@@ -171,7 +171,7 @@ pub fn clear_payload_and_transfer<T: OAppCore>(
 
     // Require authorization from the executor and transfer the value from the executor to the oapp if has value
     executor.require_auth();
-    if value > 0 {
+    if value != 0 {
         let token_client = TokenClient::new(env, &endpoint_client.native_token());
         token_client.transfer(executor, &this_address, &value);
     }

package/contracts/oapps/oft/Cargo.toml

@@ -5,15 +5,22 @@ edition.workspace = true
 license.workspace = true
 
 [lib]
-crate-type = ["rlib"]
+crate-type = ["cdylib", "rlib"]
 doctest = false
 
+[features]
+library = []
+testutils = []
+
 [dependencies]
 soroban-sdk = { workspace = true }
-endpoint-v2 = { workspace = true, features = ["library"] }
+cfg-if = { workspace = true }
 utils = { workspace = true }
-oapp = { workspace = true }
 common-macros = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+oapp = { workspace = true }
+oapp-macros = { workspace = true }
+oft-core = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
@@ -21,7 +28,3 @@ simple-message-lib = { workspace = true }
 message-lib-common = { workspace = true, features = ["testutils"] }
 endpoint-v2 = { workspace = true, features = ["testutils"] }
 utils = { workspace = true, features = ["testutils"] }
-insta = { workspace = true }
-oapp-macros = { workspace = true }
-stellar-macros = { workspace = true }
-stellar-tokens = { workspace = true }

package/contracts/oapps/{oft-std → oft}/integration-tests/extensions/test_oft_fee.rs

@@ -8,10 +8,9 @@
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
-        address_to_peer_bytes32, create_send_param, lz_receive, mint_to,
-        quote_oft, quote_send, scan_packet_sent_event, send, send_with_fee,
-        set_default_fee_bps, set_fee_bps, set_fee_deposit_address, token_balance,
-        transfer_sac_admin, validate_packet,
+        address_to_peer_bytes32, create_send_param, lz_receive, mint_to, quote_oft, quote_send,
+        scan_packet_sent_event, send, send_with_fee, set_default_fee_bps, set_fee_bps, set_fee_deposit_address,
+        token_balance, transfer_sac_admin, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};

package/contracts/oapps/{oft-std → oft}/integration-tests/extensions/test_pausable.rs

@@ -6,9 +6,8 @@
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
-        address_to_peer_bytes32, create_send_param, is_paused, lz_receive, mint_to,
-        quote_oft, quote_send, scan_packet_sent_event, send, set_paused, transfer_sac_admin,
-        try_lz_receive, try_send, validate_packet,
+        address_to_peer_bytes32, create_send_param, is_paused, lz_receive, mint_to, quote_oft, quote_send,
+        scan_packet_sent_event, send, set_paused, transfer_sac_admin, try_lz_receive, try_send, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};

package/contracts/oapps/{oft-std → oft}/integration-tests/extensions/test_rate_limiter.rs

@@ -3,6 +3,7 @@
 //! Tests verify that the RateLimiter extension properly enforces rate limits
 //! on cross-chain transfers. Uses real EndpointV2 and SimpleMessageLib.
 
+use crate::extensions::rate_limiter::Direction;
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
@@ -11,7 +12,6 @@ use crate::integration_tests::{
         try_send, validate_packet,
     },
 };
-use oft::extensions::rate_limiter::Direction;
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
 
 /// Test e2e send without rate limit (default - unlimited)

package/contracts/oapps/oft/integration-tests/mod.rs

@@ -1,3 +1,3 @@
+pub mod extensions;
 pub mod setup;
-pub mod test_with_sml;
 pub mod utils;

package/contracts/oapps/oft/integration-tests/setup.rs

@@ -1,141 +1,39 @@
-//! Integration test setup for OFT.
+//! Integration test setup for OFT-STD with real EndpointV2 and SimpleMessageLib.
 //!
-//! This file contains TestOFT contract and test setup utilities.
+//! This file contains test setup utilities for OFT-STD with all extensions enabled.
 
-extern crate self as oft;
 extern crate std;
 
-use crate::integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address};
-use common_macros::contract_impl;
-use endpoint_v2::{EndpointV2, EndpointV2Client, ILayerZeroComposer, Origin};
-use oapp::oapp_receiver::LzReceiveInternal;
-use oft::{
-    initialize_oft,
-    oft::{OFTClient, OFTInternal, OFT},
-    oft_impl,
-    storage::OFTStorage,
-    types::OFTReceipt,
+use crate::{
+    integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address},
+    oft::{OFTClient, OFT},
+    oft_types::OftType,
 };
+use endpoint_v2::{EndpointV2, EndpointV2Client};
 use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
 use soroban_sdk::{
-    contract, contractimpl, contracttype, log, symbol_short,
+    contract, contractimpl, log,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
-    token::{StellarAssetClient, TokenClient},
-    Address, Bytes, BytesN, Env, IntoVal,
+    token::TokenClient,
+    Address, BytesN, Env, IntoVal,
 };
 
 // ============================================================================
-// Test OFT Contract
+// Dummy Recipient - used to create valid contract addresses for recipients
 // ============================================================================
 
-#[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,
-    ) {
-        oft_impl::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 OFT 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 DummyComposer;
+pub struct DummyRecipient;
 
-#[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"))
-    }
+#[contractimpl]
+impl DummyRecipient {
+    pub fn __constructor(_env: &Env) {}
 }
 
-#[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,
-            },
-        );
-    }
+/// 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, ())
 }
 
 // ============================================================================
@@ -146,16 +44,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: OFTClient<'a>,
-    pub composer: DummyComposerClient<'a>,
+    pub fee_collector: Address,
 }
 
 pub struct TestSetup<'a> {
     pub env: Env,
-
     pub chain_a: ChainSetup<'a>,
     pub chain_b: ChainSetup<'a>,
 }
@@ -163,9 +61,13 @@ 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();
@@ -179,13 +81,12 @@ 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 oft_address = env.register(TestOFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals));
-    let composer_address = env.register(DummyComposer, (&endpoint_address,));
+    let mode = OftType::MintBurn;
+    let oft_address = env.register(OFT, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals, &mode));
 
     let endpoint = EndpointV2Client::new(env, &endpoint_address);
     let sml = SimpleMessageLibClient::new(env, &sml_address);
     let oft = OFTClient::new(env, &oft_address);
-    let composer = DummyComposerClient::new(env, &composer_address);
 
     // Set ZRO token in endpoint
     env.mock_auths(&[MockAuth {
@@ -202,7 +103,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, oft_token, endpoint, sml, oft, composer }
+    ChainSetup { eid, owner, native_token, zro_token, oft_token, endpoint, sml, oft, fee_collector }
 }
 
 pub fn setup<'a>() -> TestSetup<'a> {