@layerzerolabs/protocol-stellar-v2 0.2.58 → 0.2.60

package/contracts/common-macros/src/auth.rs

@@ -19,7 +19,7 @@ use syn::{parse_quote, ItemFn, ItemStruct};
 /// This macro implements `OwnableInitializer`, `Auth`, and `Ownable` traits for the contract:
 /// - `OwnableInitializer` provides `init_owner()` for constructor use
 /// - `Auth::authorizer()` returns the stored owner address
-/// - `Ownable` provides ownership management (transfer, propose, accept, renounce)
+/// - `Ownable` provides ownership management (transfer, accept, renounce)
 pub fn generate_ownable_impl(input: TokenStream) -> TokenStream {
     let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
     let name = &item_struct.ident;

package/contracts/common-macros/src/lib.rs

@@ -257,7 +257,7 @@ pub fn only_auth(_attr: TokenStream, item: TokenStream) -> TokenStream {
 /// # Requirements
 /// - The function must have an `Env` parameter
 /// - The function must have a parameter matching the first macro arg (of type `Address` or `&Address`)
-/// - The contract must use `utils::rbac` (e.g. `RbacStorage` or `RoleBasedAccessControl`)
+/// - The contract must implement `RoleBasedAccessControl` (which extends `Auth`)
 ///
 /// # Example
 /// ```ignore
@@ -273,7 +273,7 @@ pub fn only_auth(_attr: TokenStream, item: TokenStream) -> TokenStream {
 /// # Generated code
 /// ```ignore
 /// pub fn mint(env: Env, caller: Address, amount: i128) {
-///     utils::rbac::ensure_role(&env, &soroban_sdk::Symbol::new(&env, "minter"), &caller);
+///     utils::rbac::ensure_role::<Self>(&env, &soroban_sdk::Symbol::new(&env, "minter"), &caller);
 ///     // Original function body (no require_auth)
 /// }
 /// ```
@@ -307,7 +307,7 @@ pub fn has_role(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// # Generated code
 /// ```ignore
 /// pub fn mint(env: Env, caller: Address, amount: i128) {
-///     utils::rbac::ensure_role(&env, &soroban_sdk::Symbol::new(&env, "minter"), &caller);
+///     utils::rbac::ensure_role::<Self>(&env, &soroban_sdk::Symbol::new(&env, "minter"), &caller);
 ///     caller.require_auth();
 ///     // Original function body
 /// }

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

@@ -59,6 +59,7 @@ pub trait LzReceiveInternal {
 /// ```ignore
 /// use oapp::oapp_receiver::LzReceiveInternal;
 ///
+/// #[common_macros::lz_contract]
 /// #[oapp_macros::oapp]
 /// pub struct MyOApp;
 ///
@@ -112,7 +113,7 @@ pub trait OAppReceiver: OAppCore + LzReceiveInternal {
     /// # Arguments
     /// * `executor` - The address of the executor for the received message
     /// * `origin` - The origin information containing the source endpoint and sender address:
-    ///   - `src_eid`: The source chain endpoint ID
+    ///   - `src_eid`: The source endpoint ID
     ///   - `sender`: The sender address on the source chain
     ///   - `nonce`: The nonce of the message
     /// * `guid` - The unique identifier for the received LayerZero message

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

@@ -51,13 +51,13 @@ impl FeePayer {
 
 /// A helper trait for sending cross-chain messages via LayerZero.
 ///
-/// Contracts should implement this trait to gain access to the `__lz_quote` and `__lz_send` helper
+/// Contracts should implement this trait to gain access to the `__quote` and `__lz_send` helper
 /// methods for cross-chain messaging. This trait provides default implementations that handle
 /// fee payment and message dispatch through the LayerZero endpoint.
 ///
 /// # Important
 /// This trait is intended to be used as an **internal helper** only. Do **NOT** expose these
-/// methods as part of your contract's public interface (i.e., do not use `#[contractimpl]` on
+/// methods as part of your contract's public interface (i.e., do not use `#[contract_impl]` on
 /// the implementation of this trait). Instead, call these methods internally from your
 /// contract's own public functions.
 pub trait OAppSenderInternal: OAppCore {

package/contracts/oapps/oapp-macros/src/lib.rs

@@ -39,6 +39,7 @@
 //! use oapp_macros::oapp;
 //!
 //! #[oapp]
+//! #[common_macros::lz_contract]
 //! struct MyOApp;
 //!
 //! // Implement LzReceiveInternal to handle incoming messages
@@ -61,12 +62,16 @@
 //!
 //! ```ignore
 //! use oapp::oapp_receiver::LzReceiveInternal;
+//! use utils::rbac::RoleBasedAccessControl;
 //!
 //! #[oapp(custom = [core])]
+//! #[common_macros::lz_contract]
 //! struct MyOApp;
 //!
+//! // Required: `custom = [core]` skips generating both OAppCore and RoleBasedAccessControl impls
+//! impl RoleBasedAccessControl for MyOApp {}
+//!
 //! #[contractimpl(contracttrait)]
-//! #[common_macros::ownable]
 //! impl OAppCore for MyOApp {
 //!     fn oapp_version(_env: &Env) -> (u64, u64) {
 //!         (1, 1) // Custom version
@@ -84,6 +89,7 @@
 //! use oapp::oapp_receiver::{LzReceiveInternal, OAppReceiver};
 //!
 //! #[oapp(custom = [receiver])]
+//! #[common_macros::lz_contract]
 //! struct MyOrderedOApp;
 //!
 //! impl LzReceiveInternal for MyOrderedOApp {
@@ -106,12 +112,16 @@
 //!
 //! ```ignore
 //! use oapp::oapp_receiver::LzReceiveInternal;
+//! use utils::rbac::RoleBasedAccessControl;
 //!
 //! #[oapp(custom = [core, sender, options_type3])]
+//! #[common_macros::lz_contract]
 //! struct MyCustomOApp;
 //!
+//! // Required: `custom = [core]` skips generating both OAppCore and RoleBasedAccessControl impls
+//! impl RoleBasedAccessControl for MyCustomOApp {}
+//!
 //! #[contractimpl(contracttrait)]
-//! #[common_macros::ownable]
 //! impl OAppCore for MyCustomOApp { /* ... */ }
 //! impl OAppSenderInternal for MyCustomOApp { /* ... */ }
 //! #[contractimpl(contracttrait)]

package/contracts/oapps/oft/src/oft_types/mint_burn.rs

@@ -1,7 +1,8 @@
 //! MintBurn type implementation for OFT.
 //!
 //! This OFT type burns tokens on debit (send) and mints tokens on credit (receive).
-//! Used when the OFT contract has mint authority over the token.
+//! On debit, tokens are burned from the sender via the token's SEP-41 `burn`.
+//! On credit, tokens are minted to the recipient via a separate Mintable contract.
 
 use crate::interfaces::MintableClient;
 use oft_core::OFTCore;

package/contracts/oapps/oft-core/src/codec/oft_compose_msg_codec.rs

@@ -6,7 +6,7 @@ use utils::{buffer_reader::BufferReader, buffer_writer::BufferWriter};
 pub struct OFTComposeMsg {
     /// Unique sequence number for the cross-chain message packet
     pub nonce: u64,
-    /// Source chain endpoint ID where the transfer originated
+    /// Source endpoint ID where the transfer originated
     pub src_eid: u32,
     /// Amount received in local decimals
     pub amount_ld: i128,

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

@@ -2,7 +2,7 @@
 //!
 //! This module provides:
 //! - `OFTInternal`: Internal methods NOT exposed as contract entrypoints (`__debit`, `__credit`, `__initialize_oft`, `__receive`, etc.)
-//! - `OFTCore`: Public methods exposed as contract entrypoints (using `#[contracttrait]`)
+//! - `OFTCore`: Public methods exposed as contract entrypoints (using `#[contract_trait]`)
 //! - `impl_oft_lz_receive!`: Macro to implement `LzReceiveInternal` with default OFT receive logic
 //!
 //! ## Usage
@@ -11,10 +11,11 @@
 //! use oapp_macros::oapp;
 //! use oft_core::{OFTInternal, OFTCore, impl_oft_lz_receive};
 //!
+//! #[common_macros::lz_contract]
 //! #[oapp]
 //! pub struct MyOFT;
 //!
-//! #[contractimpl]
+//! #[contract_impl]
 //! impl MyOFT {
 //!     pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Address) {
 //!         Self::__initialize_oft(env, token, 6, owner, endpoint, delegate)
@@ -22,20 +23,18 @@
 //! }
 //!
 //! // Public methods - exposed as contract entrypoints
-//! #[contractimpl(contracttrait)]
+//! #[contract_impl(contracttrait)]
 //! impl OFTCore for MyOFT {}
 //!
 //! // Internal methods - NOT exposed as contract entrypoints
-//! // IMPORTANT: Do NOT use #[contractimpl] here to keep methods internal
+//! // IMPORTANT: Do NOT use #[contract_impl] here to keep methods internal
 //! impl OFTInternal for MyOFT {
-//!     fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
-//!         // Your debit logic (e.g., burn or lock tokens)
-//!         oft_core::oft_types::mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
+//!     fn __debit(env: &Env, from: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
+//!         // Your debit logic: lock tokens (LockUnlock) or burn tokens (MintBurn)
 //!     }
 //!
 //!     fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
-//!         // Your credit logic (e.g., mint or unlock tokens)
-//!         oft_core::oft_types::mint_burn::credit::<Self>(env, to, amount_ld, src_eid)
+//!         // Your credit logic: unlock tokens (LockUnlock) or mint tokens (MintBurn)
 //!     }
 //! }
 //!
@@ -136,7 +135,7 @@ pub trait OFTInternal: OAppReceiver + OAppSenderInternal + OAppOptionsType3 + Ow
     /// * `from` - The address to debit the tokens from
     /// * `amount_ld` - The amount of tokens to send in local decimals
     /// * `min_amount_ld` - The minimum amount to send in local decimals
-    /// * `dst_eid` - The destination chain ID
+    /// * `dst_eid` - The destination endpoint ID
     ///
     /// # Returns
     /// * `amount_sent_ld` - The amount sent in local decimals
@@ -418,10 +417,9 @@ pub trait OFTCore: OFTInternal {
 
     /// Indicates whether the caller must approve a token allowance before calling [`send`](OFTCore::send).
     ///
-    /// - **`false`** (default) — the OFT contract itself controls the token (mint-burn model),
-    ///   so no prior approval is needed.
-    /// - **`true`** — the OFT locks externally owned tokens (adapter model), requiring the
-    ///   sender to call `token.approve(oft_address, amount)` beforehand.
+    /// - **`false`** (default) — no separate approval step is needed.
+    /// - **`true`** — the caller must grant a token allowance to this contract before
+    ///   sending (e.g., via `token.approve(oft_address, amount, ...)`).
     ///
     /// Wallet and frontend integrators should check this to determine whether an approval
     /// transaction must precede the send.

package/package.json

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