@layerzerolabs/protocol-stellar-v2 0.2.33 → 0.2.34

package/contracts/oapps/oft/integration-tests/extensions/test_oft_fee.rs

@@ -8,9 +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,
+        address_to_peer_bytes32, create_send_param, lz_receive, mint_oft_token_to, 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,
+        token_balance, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
@@ -26,10 +26,8 @@ fn test_cross_chain_with_zero_fee() {
     let receiver = create_recipient_address(&env);
     let executor = Address::generate(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     let to = address_to_peer_bytes32(&receiver);
     let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
@@ -63,10 +61,8 @@ fn test_cross_chain_with_fee() {
     let receiver = create_recipient_address(&env);
     let executor = Address::generate(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Enable 1% fee (100 bps)
     set_fee_deposit_address(&env, &chain_a, &chain_a.fee_collector);
@@ -116,10 +112,8 @@ fn test_cross_chain_with_destination_specific_fee() {
     let receiver = create_recipient_address(&env);
     let executor = Address::generate(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Set default fee 1% and destination-specific fee 2% for chain_b
     set_fee_deposit_address(&env, &chain_a, &chain_a.fee_collector);

package/contracts/oapps/oft/integration-tests/extensions/test_pausable.rs

@@ -6,8 +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_oft_token_to, mint_to, quote_oft,
+        quote_send, scan_packet_sent_event, send, set_paused, try_lz_receive, try_send, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
@@ -22,11 +22,9 @@ fn test_send_succeeds_when_unpaused() {
     let sender = Address::generate(&env);
     let receiver = create_recipient_address(&env);
 
-    // Mint tokens and transfer admin rights
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    // Mint tokens (SAC admin is already the mock wrapper from setup)
+    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Default state should be unpaused
     assert!(!is_paused(&chain_a));
@@ -63,9 +61,8 @@ fn test_send_fails_when_paused() {
     let sender = Address::generate(&env);
     let receiver = create_recipient_address(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
 
     let to = address_to_peer_bytes32(&receiver);
     let send_param = create_send_param(&env, chain_b.eid, 1_000_000, 0, &to);
@@ -94,10 +91,8 @@ fn test_receive_fails_when_paused() {
     let receiver = create_recipient_address(&env);
     let executor = Address::generate(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Send from chain_a to chain_b
     let to = address_to_peer_bytes32(&receiver);
@@ -130,10 +125,8 @@ fn test_cross_chain_succeeds_after_unpause() {
     let receiver = create_recipient_address(&env);
     let executor = Address::generate(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 10_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 10_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Pause and then unpause
     set_paused(&env, &chain_a, true);

package/contracts/oapps/oft/integration-tests/extensions/test_rate_limiter.rs

@@ -7,9 +7,9 @@ use crate::extensions::rate_limiter::{Direction, Mode};
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
-        address_to_peer_bytes32, advance_time, create_send_param, lz_receive, mint_to, quote_oft, quote_send,
-        rate_limit_capacity, rate_limit_in_flight, scan_packet_sent_event, send, set_rate_limit, set_rate_limit_with_mode,
-        transfer_sac_admin, try_send, validate_packet,
+        address_to_peer_bytes32, advance_time, create_send_param, lz_receive, mint_oft_token_to, mint_to, quote_oft,
+        quote_send, rate_limit_capacity, rate_limit_in_flight, scan_packet_sent_event, send, set_rate_limit,
+        set_rate_limit_with_mode, try_send, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
@@ -25,10 +25,8 @@ fn test_send_without_rate_limit() {
     let receiver = create_recipient_address(&env);
     let executor = Address::generate(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 100_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 100_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Default capacity should be i128::MAX (unlimited)
     let capacity = rate_limit_capacity(&chain_a, &Direction::Outbound, chain_b.eid);
@@ -62,10 +60,8 @@ fn test_send_within_rate_limit() {
     let receiver = create_recipient_address(&env);
     let executor = Address::generate(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 100_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 100_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Set rate limit: 10M per 3600 seconds (1 hour)
     set_rate_limit(&env, &chain_a, &Direction::Outbound, chain_b.eid, 10_000_000, 3600);
@@ -112,9 +108,8 @@ fn test_send_exceeds_rate_limit() {
     let sender = Address::generate(&env);
     let receiver = create_recipient_address(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 100_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 100_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
 
     // Set rate limit: 1M per 3600 seconds
     set_rate_limit(&env, &chain_a, &Direction::Outbound, chain_b.eid, 1_000_000, 3600);
@@ -140,10 +135,8 @@ fn test_rate_limit_decay() {
     let receiver = create_recipient_address(&env);
     let executor = Address::generate(&env);
 
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender, 100_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender, 100_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Set rate limit: 10M per 1000 seconds
     set_rate_limit(&env, &chain_a, &Direction::Outbound, chain_b.eid, 10_000_000, 1000);
@@ -199,12 +192,10 @@ fn test_gross_mode_does_not_release() {
     let executor = Address::generate(&env);
 
     // Setup tokens for both chains
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender_a, 100_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender_a, 100_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender_a, 10_000_000_000);
-    mint_to(&env, &chain_b.owner, &chain_b.oft_token, &sender_b, 100_000_000);
+    mint_oft_token_to(&env, &chain_b, &sender_b, 100_000_000);
     mint_to(&env, &chain_b.owner, &chain_b.native_token, &sender_b, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Set Gross mode rate limit on chain_a outbound: 10M per 3600 seconds
     set_rate_limit_with_mode(&env, &chain_a, &Direction::Outbound, chain_b.eid, 10_000_000, 3600, Mode::Gross);
@@ -267,12 +258,10 @@ fn test_net_mode_does_release() {
     let executor = Address::generate(&env);
 
     // Setup tokens for both chains
-    mint_to(&env, &chain_a.owner, &chain_a.oft_token, &sender_a, 100_000_000);
+    mint_oft_token_to(&env, &chain_a, &sender_a, 100_000_000);
     mint_to(&env, &chain_a.owner, &chain_a.native_token, &sender_a, 10_000_000_000);
-    mint_to(&env, &chain_b.owner, &chain_b.oft_token, &sender_b, 100_000_000);
+    mint_oft_token_to(&env, &chain_b, &sender_b, 100_000_000);
     mint_to(&env, &chain_b.owner, &chain_b.native_token, &sender_b, 10_000_000_000);
-    transfer_sac_admin(&env, &chain_a.owner, &chain_a.oft_token, &chain_a.oft.address);
-    transfer_sac_admin(&env, &chain_b.owner, &chain_b.oft_token, &chain_b.oft.address);
 
     // Set Net mode rate limit on chain_a outbound: 10M per 3600 seconds
     set_rate_limit_with_mode(&env, &chain_a, &Direction::Outbound, chain_b.eid, 10_000_000, 3600, Mode::Net);

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

@@ -12,12 +12,40 @@ use crate::{
 use endpoint_v2::{EndpointV2, EndpointV2Client};
 use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
 use soroban_sdk::{
-    contract, contractimpl, log,
+    contract, contractimpl, contracttype, log,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
-    token::TokenClient,
+    token::{StellarAssetClient, TokenClient},
     Address, BytesN, Env, IntoVal,
 };
 
+// ============================================================================
+// Mock SAC Wrapper - implements Mintable for integration tests
+// ============================================================================
+// Wraps a Stellar Asset Contract (SAC). The wrapper is set as SAC admin and
+// implements mint(env, to, amount, operation) so the OFT uses it for credit (mint).
+// OFT burns on the token directly; this mock still has burn for completeness.
+
+#[contracttype]
+pub enum MockSacWrapperKey {
+    Sac,
+}
+
+#[contract]
+pub struct MockSacWrapper;
+
+#[contractimpl]
+impl MockSacWrapper {
+    pub fn __constructor(env: &Env, sac: Address) {
+        env.storage().instance().set(&MockSacWrapperKey::Sac, &sac);
+    }
+
+    /// Mintable::mint - mints on the underlying SAC (wrapper must be SAC admin).
+    pub fn mint(env: &Env, to: &Address, amount: i128, _operation: &Address) {
+        let sac: Address = env.storage().instance().get(&MockSacWrapperKey::Sac).unwrap();
+        StellarAssetClient::new(env, &sac).mint(to, &amount);
+    }
+}
+
 // ============================================================================
 // Dummy Recipient - used to create valid contract addresses for recipients
 // ============================================================================
@@ -45,7 +73,10 @@ pub struct ChainSetup<'a> {
     pub owner: Address,
     pub native_token: Address,
     pub zro_token: Address,
+    /// Underlying SAC for the OFT token (used for balance, transfer, mint_to).
     pub oft_token: Address,
+    /// Mock SAC wrapper implementing Mintable; OFT uses it for mint on credit.
+    pub sac_wrapper: Address,
     pub endpoint: EndpointV2Client<'a>,
     pub sml: SimpleMessageLibClient<'a>,
     pub oft: OFTClient<'a>,
@@ -72,9 +103,20 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let zro_token = zro_sac.address();
 
-    // Create OFT token
+    // Create OFT token (SAC) and a mock SAC wrapper that implements Mintable.
     let oft_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let oft_token = oft_sac.address();
+    let sac_wrapper_address = env.register(MockSacWrapper, (&oft_token,));
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &oft_token,
+            fn_name: "set_admin",
+            args: (&sac_wrapper_address,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    StellarAssetClient::new(env, &oft_token).set_admin(&sac_wrapper_address);
 
     let eid: u32 = 30400; // Test EID
     let endpoint_address = env.register(EndpointV2, (&owner, eid, &native_token));
@@ -82,9 +124,8 @@ 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
-    // Both chains use MintBurn — the SAC itself implements mint/burn.
-    // This exercises the MintBurnableClient code path.
-    let mode = OftType::MintBurn(oft_token.clone());
+                                  // MintBurn with SAC wrapper: OFT uses wrapper for mint on credit; burn is on token directly.
+    let mode = OftType::MintBurn(sac_wrapper_address.clone());
     let oft_address = env.register(OFT, (&oft_token, &shared_decimals, &mode, &owner, &endpoint_address, &delegate));
 
     let endpoint = EndpointV2Client::new(env, &endpoint_address);
@@ -104,7 +145,18 @@ fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
     endpoint.set_zro(&zro_token);
 
     register_library(env, &owner, &endpoint, &sml.address);
-    ChainSetup { eid, owner, native_token, zro_token, oft_token, endpoint, sml, oft, fee_collector }
+    ChainSetup {
+        eid,
+        owner,
+        native_token,
+        zro_token,
+        oft_token,
+        sac_wrapper: sac_wrapper_address,
+        endpoint,
+        sml,
+        oft,
+        fee_collector,
+    }
 }
 
 pub fn setup<'a>() -> TestSetup<'a> {

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

@@ -2,6 +2,7 @@
 
 use crate::extensions::rate_limiter::{Direction, Mode, RateLimitConfig};
 use crate::integration_tests::setup::{decode_packet, ChainSetup};
+use crate::MintableClient;
 use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
 use message_lib_common::packet_codec_v1;
 use oft_core::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam};
@@ -38,7 +39,11 @@ pub fn create_recipient_address(env: &Env) -> Address {
 // OFT Core Operations
 // ============================================================================
 
-pub fn quote_oft(chain: &ChainSetup<'_>, from: &Address, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
+pub fn quote_oft(
+    chain: &ChainSetup<'_>,
+    from: &Address,
+    send_param: &SendParam,
+) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
     chain.oft.quote_oft(from, send_param)
 }
 
@@ -61,7 +66,8 @@ pub fn quote_send(
     chain.oft.quote_send(sender, send_param, &pay_in_zro)
 }
 
-/// Send without fee (standard OFT send)
+/// Send without fee (standard OFT send).
+/// Sender authorizes OFT send (OFT debits by calling token burn directly) and SAC burn.
 pub fn send(
     env: &Env,
     chain: &ChainSetup<'_>,
@@ -308,6 +314,26 @@ pub fn mint_to(env: &Env, owner: &Address, token: &Address, to: &Address, amount
     sac.mint(to, &amount);
 }
 
+/// Mints the OFT token (via the Mintable wrapper) to the given address.
+/// Use when OFT is MintBurn; the wrapper calls the underlying SAC mint.
+pub fn mint_oft_token_to(env: &Env, chain: &ChainSetup<'_>, to: &Address, amount: i128) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.sac_wrapper,
+            fn_name: "mint",
+            args: (to, &amount, &chain.owner).into_val(env),
+            sub_invokes: &[MockAuthInvoke {
+                contract: &chain.oft_token,
+                fn_name: "mint",
+                args: (to, &amount).into_val(env),
+                sub_invokes: &[],
+            }],
+        },
+    }]);
+    MintableClient::new(env, &chain.sac_wrapper).mint(to, &amount, &chain.owner);
+}
+
 pub fn transfer_sac_admin(env: &Env, owner: &Address, token: &Address, new_admin: &Address) {
     env.mock_auths(&[MockAuth {
         address: owner,

package/contracts/oapps/oft/src/interfaces/mintable.rs

@@ -0,0 +1,14 @@
+//! Mintable trait - the interface the OFT uses to mint tokens on credit (receive).
+
+use soroban_sdk::{contractclient, Address, Env};
+
+/// The mint interface for OFT MintBurn operations.
+///
+/// A contract that implements `mint` (e.g. SAC Manager or a token wrapper) is used
+/// for crediting; the OFT calls the token (SAC) directly for burn on debit.
+#[contractclient(name = "MintableClient")]
+pub trait Mintable {
+    /// Mints `amount` tokens to `to`. The `operation` address is the caller (e.g. OFT)
+    /// requesting the mint, for use by SAC wrappers that enforce authorization.
+    fn mint(env: &Env, to: &Address, amount: i128, operation: &Address);
+}

package/contracts/oapps/oft/src/interfaces/mod.rs

@@ -1,3 +1,3 @@
-mod mint_burnable;
+mod mintable;
 
-pub use mint_burnable::*;
+pub use mintable::*;

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

@@ -110,8 +110,8 @@ impl OFTInternal for OFT {
             OftType::LockUnlock => {
                 lock_unlock::debit::<Self>(env, &Self::token(env), sender, amount_ld, min_amount_ld, dst_eid)
             }
-            OftType::MintBurn(mint_burnable) => {
-                mint_burn::debit::<Self>(env, &mint_burnable, sender, amount_ld, min_amount_ld, dst_eid)
+            OftType::MintBurn(_mintable) => {
+                mint_burn::debit::<Self>(env, &Self::token(env), sender, amount_ld, min_amount_ld, dst_eid)
             }
         };
 
@@ -133,7 +133,7 @@ impl OFTInternal for OFT {
         // Core credit logic (based on mode)
         let amount_credited = match Self::oft_type(env) {
             OftType::LockUnlock => lock_unlock::credit::<Self>(env, &Self::token(env), to, amount_ld, src_eid),
-            OftType::MintBurn(mint_burnable) => mint_burn::credit::<Self>(env, &mint_burnable, to, amount_ld, src_eid),
+            OftType::MintBurn(mintable) => mint_burn::credit::<Self>(env, &mintable, to, amount_ld, src_eid),
         };
 
         // Rate limit checks

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

@@ -1,17 +1,17 @@
 //! 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/burn authority over the token.
+//! Used when the OFT contract has mint authority over the token.
 
-use crate::interfaces::MintBurnableClient;
+use crate::interfaces::MintableClient;
 use oft_core::OFTCore;
-use soroban_sdk::{Address, Env};
+use soroban_sdk::{token::TokenClient, Address, Env};
 
 /// Debit tokens using MintBurn OFT type (burns tokens from sender).
 ///
 /// # Parameters
 /// * `env` - The Soroban environment
-/// * `burnable` - Address of the contract responsible for burning tokens
+/// * `token` - Address of the token (SAC) to burn from
 /// * `sender` - Address of the token sender
 /// * `amount_ld` - Amount to debit in local decimals
 /// * `min_amount_ld` - Minimum amount that must be received (for slippage protection)
@@ -22,14 +22,14 @@ use soroban_sdk::{Address, Env};
 /// * `amount_received_ld` - The amount received in local decimals on the remote
 pub fn debit<T: OFTCore>(
     env: &Env,
-    burnable: &Address,
+    token: &Address,
     sender: &Address,
     amount_ld: i128,
     min_amount_ld: i128,
     dst_eid: u32,
 ) -> (i128, i128) {
     let (amount_sent_ld, amount_received_ld) = T::__debit_view(env, amount_ld, min_amount_ld, dst_eid);
-    MintBurnableClient::new(env, burnable).burn(sender, &amount_received_ld);
+    TokenClient::new(env, token).burn(sender, &amount_received_ld);
     (amount_sent_ld, amount_received_ld)
 }
 
@@ -37,7 +37,7 @@ pub fn debit<T: OFTCore>(
 ///
 /// # Parameters
 /// * `env` - The Soroban environment
-/// * `mintable` - Address of the contract responsible for minting tokens
+/// * `mintable` - Address of the contract responsible for minting tokens (e.g. SAC wrapper)
 /// * `to` - Address of the token recipient
 /// * `amount_ld` - Amount to credit in local decimals
 /// * `_src_eid` - Source endpoint ID (unused)
@@ -45,6 +45,6 @@ pub fn debit<T: OFTCore>(
 /// # Returns
 /// The amount credited
 pub fn credit<T: OFTCore>(env: &Env, mintable: &Address, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
-    MintBurnableClient::new(env, mintable).mint(to, &amount_ld);
+    MintableClient::new(env, mintable).mint(to, &amount_ld, &env.current_contract_address());
     amount_ld
 }

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

@@ -4,9 +4,8 @@
 //!
 //! - **LockUnlock**: Locks tokens on send, unlocks on receive. Operates directly on the
 //!   token via standard SEP-41 `transfer`.
-//! - **MintBurn**: Burns tokens on send, mints on receive. Operates on any contract
-//!   that implements [`MintBurnable`](crate::interfaces::MintBurnable) —
-//!   whether it's a raw SAC or a token wrapper (e.g. SAC Manager).
+//! - **MintBurn**: Burns tokens on send (via TokenClient on the token), mints on receive
+//!   via a contract that implements [`Mintable`](crate::interfaces::Mintable).
 
 use soroban_sdk::{contracttype, Address};
 
@@ -20,6 +19,6 @@ pub enum OftType {
     /// Lock tokens on send, unlock on receive.
     LockUnlock,
     /// Burn tokens on send, mint on receive.
-    /// The address is the contract responsible for minting and burning tokens.
+    /// The address is the Mintable contract used for minting on credit
     MintBurn(Address),
 }

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

@@ -1,7 +1,9 @@
 extern crate std;
 
 use crate as oft;
-use crate::extensions::rate_limiter::{Direction, Mode, RateLimitConfig, RateLimitError, RateLimiter, RateLimiterInternal};
+use crate::extensions::rate_limiter::{
+    Direction, Mode, RateLimitConfig, RateLimitError, RateLimiter, RateLimiterInternal,
+};
 use soroban_sdk::{contract, contractimpl, testutils::Ledger as _, Address, Env};
 use utils::auth::Auth;
 
@@ -451,10 +453,10 @@ fn test_switching_from_net_to_gross_mode() {
 
     // Switch to Gross mode
     client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 100, Mode::Gross)));
-    
+
     // in-flight should be checkpointed
     assert_eq!(client.rate_limit_in_flight(&direction, &eid), 40);
-    
+
     // Now releases should be no-op
     client.release(&direction, &eid, &20i128);
     assert_eq!(client.rate_limit_in_flight(&direction, &eid), 40, "Gross mode should not release");
@@ -474,10 +476,10 @@ fn test_switching_from_gross_to_net_mode() {
 
     // Switch to Net mode
     client.set_rate_limit(&direction, &eid, &Some(config_with_mode(100, 100, Mode::Net)));
-    
+
     // in-flight should be checkpointed
     assert_eq!(client.rate_limit_in_flight(&direction, &eid), 60);
-    
+
     // Now releases should work
     client.release(&direction, &eid, &20i128);
     assert_eq!(client.rate_limit_in_flight(&direction, &eid), 40, "Net mode should release");

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

@@ -0,0 +1,14 @@
+//! General errors for the SAC Manager contract.
+
+use common_macros::contract_error;
+
+/// General SacManagerError: 3220-3249
+#[contract_error]
+pub enum SacManagerError {
+    /// The address is already a minter
+    AlreadyMinter,
+    /// Minter address not in the minters list (e.g. when deactivating)
+    MinterNotFound,
+    /// Caller is not authorized for this operation
+    Unauthorized,
+}

package/contracts/{sac-manager → oapps/sac-manager}/src/lib.rs

@@ -1,12 +1,8 @@
 #![no_std]
 
-pub mod extensions;
-
 mod errors;
-mod interfaces;
 
 pub use errors::*;
-pub use interfaces::*;
 
 cfg_if::cfg_if! {
     // Include implementation when NOT in library mode, OR when testutils is enabled (for tests)