@layerzerolabs/protocol-stellar-v2 0.2.51 → 0.2.52

package/contracts/oapps/console-oft/src/tests/mod.rs

@@ -0,0 +1,2 @@
+mod extensions;
+mod oft_types;

package/contracts/oapps/console-oft/src/tests/oft_types/lock_unlock.rs

@@ -0,0 +1,185 @@
+extern crate std;
+
+use crate::oft_types::lock_unlock;
+use endpoint_v2::Origin;
+use oapp::oapp_receiver::{LzReceiveInternal, OAppReceiver};
+use oft_core::{OFTCore, OFTInternal, OFTReceipt};
+use soroban_sdk::{
+    contract, contractimpl, contracttype,
+    testutils::Address as _,
+    token::{StellarAssetClient, TokenClient},
+    Address, Bytes, BytesN, Env,
+};
+
+// ============================================================================
+// Mock Contracts
+// ============================================================================
+
+#[contract]
+struct DummyEndpoint;
+
+#[derive(Clone)]
+#[contracttype]
+enum DummyEndpointDataKey {
+    Delegate(Address),
+}
+
+#[contractimpl]
+impl DummyEndpoint {
+    pub fn set_delegate(env: Env, oapp: &Address, delegate: &Option<Address>) {
+        let key = DummyEndpointDataKey::Delegate(oapp.clone());
+        match delegate {
+            Some(d) => env.storage().persistent().set(&key, d),
+            None => env.storage().persistent().remove(&key),
+        }
+    }
+}
+
+// ============================================================================
+// LockUnlock OFT Harness Contract
+// ============================================================================
+
+#[common_macros::lz_contract]
+#[oapp_macros::oapp(custom = [receiver])]
+pub struct LockUnlockHarnessOFT;
+
+#[contractimpl]
+impl LockUnlockHarnessOFT {
+    pub fn __constructor(
+        env: &Env,
+        token: &Address,
+        owner: &Address,
+        endpoint: &Address,
+        delegate: &Address,
+        shared_decimals: u32,
+    ) {
+        Self::__initialize_oft(env, token, shared_decimals, owner, endpoint, delegate);
+    }
+
+    pub fn debit(env: Env, sender: Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        let (amount_sent_ld, amount_received_ld) =
+            <Self as OFTInternal>::__debit(&env, &sender, amount_ld, min_amount_ld, dst_eid);
+        OFTReceipt { amount_sent_ld, amount_received_ld }
+    }
+
+    pub fn credit(env: Env, to: Address, amount_ld: i128, src_eid: u32) -> i128 {
+        <Self as OFTInternal>::__credit(&env, &to, amount_ld, src_eid)
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OFTCore for LockUnlockHarnessOFT {}
+
+impl LzReceiveInternal for LockUnlockHarnessOFT {
+    fn __lz_receive(
+        env: &Env,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        extra_data: &Bytes,
+        executor: &Address,
+        value: i128,
+    ) {
+        <Self as OFTInternal>::__receive(env, origin, guid, message, extra_data, executor, value)
+    }
+}
+
+#[contractimpl(contracttrait)]
+impl OAppReceiver for LockUnlockHarnessOFT {}
+
+impl OFTInternal for LockUnlockHarnessOFT {
+    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
+        let target = Self::token(env);
+        lock_unlock::debit::<Self>(env, &target, sender, amount_ld, min_amount_ld, dst_eid)
+    }
+
+    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
+        let target = Self::token(env);
+        lock_unlock::credit::<Self>(env, &target, to, amount_ld, src_eid)
+    }
+}
+
+// ============================================================================
+// Test Setup
+// ============================================================================
+
+struct TestSetup {
+    env: Env,
+    client: LockUnlockHarnessOFTClient<'static>,
+    oft_address: Address,
+    token: Address,
+}
+
+fn setup() -> TestSetup {
+    let env = Env::default();
+    // Enable mock_all_auths_allowing_non_root_auth for all tests to bypass authorization checks
+    // including sub-contract invocations like token transfers
+    env.mock_all_auths_allowing_non_root_auth();
+
+    let token_admin = Address::generate(&env);
+    let sac = env.register_stellar_asset_contract_v2(token_admin.clone());
+    let token = sac.address();
+    let endpoint = env.register(DummyEndpoint, ());
+
+    let owner = Address::generate(&env);
+    let delegate = owner.clone();
+    let shared_decimals: u32 = 6;
+
+    let oft_address = env.register(LockUnlockHarnessOFT, (&token, &owner, &endpoint, &delegate, &shared_decimals));
+    let client = LockUnlockHarnessOFTClient::new(&env, &oft_address);
+
+    TestSetup { env, client, oft_address, token }
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+#[test]
+fn test_debit_transfers_to_contract() {
+    let TestSetup { env, client, oft_address, token, .. } = setup();
+
+    let sender = Address::generate(&env);
+
+    // Auth is automatically mocked by mock_all_auths_allowing_non_root_auth
+    StellarAssetClient::new(&env, &token).mint(&sender, &1_000_000i128);
+
+    let token_client = TokenClient::new(&env, &token);
+    let sender_before = token_client.balance(&sender);
+    let contract_before = token_client.balance(&oft_address);
+
+    // With shared_decimals=6 and typical SAC decimals=7, conversion_rate=10 => 105 -> 100.
+    // debit transfers from sender to OFT contract
+    let amount_ld = 105i128;
+
+    let receipt = client.debit(&sender, &amount_ld, &0i128, &999u32);
+    assert_eq!(receipt.amount_sent_ld, receipt.amount_received_ld);
+
+    // LockUnlock transfers `amount_received_ld` from sender -> contract.
+    assert_eq!(token_client.balance(&sender), sender_before - receipt.amount_received_ld);
+    assert_eq!(token_client.balance(&oft_address), contract_before + receipt.amount_received_ld);
+}
+
+#[test]
+fn test_credit_transfers_from_contract() {
+    let TestSetup { env, client, oft_address, token, .. } = setup();
+
+    let recipient = Address::generate(&env);
+
+    // Auth is automatically mocked by mock_all_auths_allowing_non_root_auth
+    StellarAssetClient::new(&env, &token).mint(&oft_address, &1_000_000i128);
+
+    let token_client = TokenClient::new(&env, &token);
+    let contract_before = token_client.balance(&oft_address);
+    let recipient_before = token_client.balance(&recipient);
+
+    // credit transfers from OFT contract to recipient
+    let amount = 123i128;
+
+    let credited = client.credit(&recipient, &amount, &1u32);
+    assert_eq!(credited, amount);
+
+    // LockUnlock transfers `amount` from contract -> recipient.
+    assert_eq!(token_client.balance(&oft_address), contract_before - amount);
+    assert_eq!(token_client.balance(&recipient), recipient_before + amount);
+}

package/contracts/oapps/console-oft/src/tests/oft_types/mod.rs

@@ -0,0 +1 @@
+mod lock_unlock;

package/contracts/oapps/oft/src/extensions/oft_fee.rs

@@ -1,8 +1,11 @@
 use common_macros::{contract_error, contract_trait, only_role, storage};
 use soroban_sdk::{assert_with_error, contractevent, token::TokenClient, Address, Env};
-use utils::{option_ext::OptionExt, rbac::{RoleBasedAccessControl, AUTHORIZER}};
+use utils::{
+    option_ext::OptionExt,
+    rbac::{RoleBasedAccessControl, AUTHORIZER},
+};
 
-/// Role for fee configuration (set_default_fee_bps, set_fee_bps, set_fee_deposit_address).
+/// Role for fee configuration (set_default_fee_bps, set_fee_bps).
 pub const FEE_CONFIG_MANAGER_ROLE: &str = "FEE_CONFIG_MANAGER_ROLE";
 
 /// Base fee in basis points (10,000 BPS = 100%)

package/contracts/oapps/oft/src/tests/extensions/oft_fee.rs

@@ -1,7 +1,7 @@
 extern crate std;
 
-use crate::extensions::oft_fee::{OFTFee, OFTFeeError, OFTFeeInternal};
 use crate::extensions::oft_fee::FEE_CONFIG_MANAGER_ROLE;
+use crate::extensions::oft_fee::{OFTFee, OFTFeeError, OFTFeeInternal};
 use soroban_sdk::{
     contract, contractimpl,
     testutils::{Address as _, MockAuth, MockAuthInvoke},

package/contracts/oapps/sac-manager/src/sac_manager.rs

@@ -4,6 +4,14 @@
 //! - Mintable interface for OFT (mint on credit only; OFT burns on the token directly)
 //! - Role-based access control operations (clawback, set_admin, set_authorized)
 //!
+//! ## Trust Model Requirement
+//!
+//! **The issuer account must be locked (master weight set to 0).** In Stellar classic assets,
+//! transfers from/to the issuer are equivalent to minting/burning. The issuer can always mint
+//! more tokens and perform other classic operations directly, even when an explicit admin (this
+//! contract) is set. If the issuer account is not locked, the RBAC model enforced by this
+//! contract can be bypassed, breaking the trust model.
+//!
 //! ## Authorization Model
 //!
 //! - **Owner** (via Ownable): The deployer/admin address. Can manage TTL and grant/revoke roles.

package/contracts/workers/worker/src/worker.rs

@@ -46,6 +46,12 @@ pub trait Worker: Auth {
     /// Admins can configure worker settings like fee multipliers, deposit addresses,
     /// and supported option types.
     ///
+    /// **Address type requirement:** Admins used for execute/compose flows (Executor)
+    /// or custom account auth (DVN) must be Ed25519 accounts. Contract-type addresses
+    /// cannot participate in custom account authorization. Only Ed25519 account
+    /// addresses can sign for execute/compose and DVN admin operations. Contract-type
+    /// admins are not supported for these flows;
+    ///
     /// # Arguments
     /// * `admin` - The address to set admin status for
     /// * `active` - `true` to add admin, `false` to remove
@@ -306,7 +312,8 @@ pub trait Worker: Auth {
 /// This function should be called only once to initialize the worker once.
 ///
 /// # Arguments
-/// * `admins` - Initial admin addresses (must not be empty)
+/// * `admins` - Initial admin addresses (must not be empty). Admins used for
+///   execute/compose or custom account auth must be Ed25519 (see `set_admin`).
 /// * `message_libs` - Supported message library addresses
 /// * `price_feed` - Price feed contract address
 /// * `default_multiplier_bps` - Default fee multiplier in basis points

package/docs/oft-guide.md

@@ -256,7 +256,7 @@ impl OFTFeeInternal for MyOFT {}
 
 // Override __debit_view to apply fee:
 fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-    let fee = Self::__fee_view(env, dst_eid, amount_ld);
+    let fee = Self::__get_fee(env, dst_eid, amount_ld);
     let amount_after_fee = amount_ld - fee;
     // ... rest of logic
 }
@@ -267,7 +267,7 @@ Usage:
 ```rust
 oft.set_default_fee_bps(100);              // 1% default fee (owner only)
 oft.set_fee_bps(dst_eid, Some(50));        // 0.5% for specific destination
-oft.set_fee_deposit_address(fee_addr);     // Where fees go
+oft.set_fee_deposit(fee_addr);             // Where fees go
 ```
 
 ### Rate limiter

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@layerzerolabs/protocol-stellar-v2",
-  "version": "0.2.51",
+  "version": "0.2.52",
   "private": false,
   "license": "LZBL-1.2",
   "devDependencies": {
     "@types/node": "^22.18.6",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
-    "@layerzerolabs/common-node-utils": "0.2.51",
-    "@layerzerolabs/vm-tooling-stellar": "0.2.51",
-    "@layerzerolabs/stellar-ts-bindings-gen": "0.2.51"
+    "@layerzerolabs/stellar-ts-bindings-gen": "0.2.52",
+    "@layerzerolabs/vm-tooling-stellar": "0.2.52",
+    "@layerzerolabs/common-node-utils": "0.2.52"
   },
   "publishConfig": {
     "access": "restricted",