@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.123

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

@@ -1,14 +0,0 @@
-//! 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 `operator` 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, operator: &Address);
-}

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

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

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

@@ -1,24 +0,0 @@
-#![no_std]
-
-mod extensions;
-mod interfaces;
-mod oft_types;
-
-pub use extensions::*;
-pub use interfaces::*;
-pub use oft_types::*;
-
-cfg_if::cfg_if! {
-    // Include implementation when NOT in library mode, OR when testutils is enabled (for tests)
-    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
-        mod oft;
-        pub use oft::*;
-    }
-}
-
-#[cfg(test)]
-#[path = "../integration-tests/mod.rs"]
-pub mod integration_tests;
-
-#[cfg(test)]
-mod tests;

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

@@ -1,176 +0,0 @@
-use crate::{
-    self as oft,
-    extensions::{
-        oft_fee::{OFTFee, OFTFeeInternal},
-        pausable::{OFTPausable, OFTPausableInternal},
-        rate_limiter::{Direction, RateLimiter, RateLimiterInternal},
-    },
-    oft_types::{lock_unlock, mint_burn, OftType},
-};
-use common_macros::{contract_impl, lz_contract, storage};
-use oapp_macros::oapp;
-use oft_core::{
-    impl_oft_lz_receive, utils as oft_utils, OFTCore, OFTError, OFTFeeDetail, OFTInternal, OFTLimit, OFTReceipt,
-    SendParam,
-};
-use soroban_sdk::{assert_with_error, Address, Bytes, Env, Vec};
-
-// =========================================================================
-// Storage
-// =========================================================================
-
-#[storage]
-enum OFTStorage {
-    #[instance(OftType)]
-    OftType,
-}
-
-// =========================================================================
-// OFT Contract
-// =========================================================================
-
-#[lz_contract]
-#[oapp]
-pub struct OFT;
-
-// LzReceiveInternal implementation using default OFT receive logic
-impl_oft_lz_receive!(OFT);
-
-#[contract_impl]
-impl OFT {
-    pub fn __constructor(
-        env: &Env,
-        token: &Address,
-        shared_decimals: u32,
-        oft_type: OftType,
-        endpoint: &Address,
-        delegate: &Address,
-    ) {
-        Self::__initialize_oft(env, token, shared_decimals, delegate, endpoint, delegate);
-        OFTStorage::set_oft_type(env, &oft_type);
-    }
-
-    /// Returns the OFT type with its target address and configuration.
-    pub fn oft_type(env: &Env) -> OftType {
-        OFTStorage::oft_type(env).unwrap()
-    }
-}
-
-/// OFTCore trait implementation for standard OFT with extensions
-#[contract_impl(contracttrait)]
-impl OFTCore for OFT {
-    fn quote_oft(env: &Env, from: &Address, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
-        let (mut limit, mut fee_details, receipt) = Self::__quote_oft(env, from, send_param);
-
-        // fee details (only include if there's an actual fee)
-        if receipt.amount_sent_ld > receipt.amount_received_ld {
-            let fee_amount_ld = receipt.amount_sent_ld - receipt.amount_received_ld;
-            fee_details.push_back(OFTFeeDetail { fee_amount_ld, description: Bytes::from_slice(env, b"OFT Fee") });
-        };
-
-        // Rate limit capacity, capped to u64::MAX (the safe ceiling from __quote_oft default)
-        let mut max_amount_ld = Self::rate_limit_capacity(env, &Direction::Outbound, send_param.dst_eid);
-        if max_amount_ld != i128::MAX {
-            // Back-calculate pre-fee amount so max_amount_ld represents the largest input to send()
-            max_amount_ld = Self::__amount_before_fee(env, send_param.dst_eid, max_amount_ld);
-        } else {
-            // No rate limit configured — use the bounded default
-            max_amount_ld = u64::MAX as i128;
-        }
-        limit.max_amount_ld = max_amount_ld;
-
-        (limit, fee_details, receipt)
-    }
-}
-
-/// OFT behavior for standard OFT with extension hooks
-impl OFTInternal for OFT {
-    /// Overrides default to add pausable check and fee calculation.
-    ///
-    /// Dust handling (consistent with EVM):
-    /// - no fee: dust stays with sender (amount_sent_ld has dust removed)
-    /// - has fee: dust is absorbed into the charged fee (amount_sent_ld is the full amount)
-    fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
-        Self::__assert_not_paused(env);
-
-        let conversion_rate = Self::__decimal_conversion_rate(env);
-        let has_fee = Self::has_oft_fee(env, dst_eid);
-
-        let (amount_sent_ld, amount_received_ld) = if !has_fee {
-            // No fee: dust stays with sender (default OFT behavior)
-            let amount_sent_ld = oft_utils::remove_dust(amount_ld, conversion_rate);
-            (amount_sent_ld, amount_sent_ld)
-        } else {
-            // With fee: match EVM OFTFee behavior
-            // - sender pays full amount_ld (no dust removed), dust is absorbed into the charged fee
-            let fee = Self::__fee_view(env, dst_eid, amount_ld);
-            let amount_received_ld = oft_utils::remove_dust(amount_ld - fee, conversion_rate);
-            (amount_ld, amount_received_ld)
-        };
-
-        assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
-
-        (amount_sent_ld, amount_received_ld)
-    }
-
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> (i128, i128) {
-        // Core debit logic (based on oft_type)
-        let (amount_sent_ld, amount_received_ld) = match Self::oft_type(env) {
-            OftType::LockUnlock => {
-                lock_unlock::debit::<Self>(env, &Self::token(env), 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)
-            }
-        };
-
-        // Rate limit checks (using amount_received_ld - the actual cross-chain amount)
-        Self::__consume_rate_limit_capacity(env, &Direction::Outbound, dst_eid, amount_received_ld);
-        Self::__release_rate_limit_capacity(env, &Direction::Inbound, dst_eid, amount_received_ld);
-
-        // Charge fee
-        let fee = amount_sent_ld - amount_received_ld;
-        Self::__charge_fee(env, &Self::token(env), sender, fee);
-
-        (amount_sent_ld, amount_received_ld)
-    }
-
-    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
-        // Pausable check
-        Self::__assert_not_paused(env);
-
-        // 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(mintable) => mint_burn::credit::<Self>(env, &mintable, to, amount_ld, src_eid),
-        };
-
-        // Rate limit checks
-        Self::__consume_rate_limit_capacity(env, &Direction::Inbound, src_eid, amount_ld);
-        Self::__release_rate_limit_capacity(env, &Direction::Outbound, src_eid, amount_ld);
-
-        amount_credited
-    }
-}
-
-// =========================================================================
-// Extension Trait Implementations
-// =========================================================================
-
-/// Pausable extension - allows pausing/unpausing the OFT
-/// Default state: unpaused (all operations allowed)
-#[contract_impl(contracttrait)]
-impl OFTPausable for OFT {}
-impl OFTPausableInternal for OFT {}
-
-/// OFT Fee extension - allows collecting fees on transfers
-/// Default state: 0 BPS (no fee collected)
-#[contract_impl(contracttrait)]
-impl OFTFee for OFT {}
-impl OFTFeeInternal for OFT {}
-
-/// Rate Limiter extension - allows rate limiting transfers
-/// Default state: not set (rate_limit_capacity returns i128::MAX)
-#[contract_impl(contracttrait)]
-impl RateLimiter for OFT {}
-impl RateLimiterInternal for OFT {}

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

@@ -1,50 +0,0 @@
-//! LockUnlock type implementation for OFT.
-//!
-//! This OFT type locks tokens in the contract on debit (send) and unlocks
-//! tokens from the contract on credit (receive).
-//! Operates directly on the token via standard SEP-41 `transfer`.
-
-use oft_core::OFTCore;
-use soroban_sdk::{token::TokenClient, Address, Env};
-
-/// Debit tokens using LockUnlock OFT type (locks tokens in contract).
-///
-/// # Parameters
-/// * `env` - The Soroban environment
-/// * `token` - Address of the token
-/// * `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)
-/// * `dst_eid` - Destination endpoint ID
-///
-/// # Returns
-/// * `amount_sent_ld` - The amount sent in local decimals
-/// * `amount_received_ld` - The amount received in local decimals on the remote
-pub fn debit<T: OFTCore>(
-    env: &Env,
-    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);
-    TokenClient::new(env, token).transfer(sender, env.current_contract_address(), &amount_received_ld);
-    (amount_sent_ld, amount_received_ld)
-}
-
-/// Credit tokens using LockUnlock OFT type (unlocks tokens from contract).
-///
-/// # Parameters
-/// * `env` - The Soroban environment
-/// * `token` - Address of the token
-/// * `to` - Address of the token recipient
-/// * `amount_ld` - Amount to credit in local decimals
-/// * `_src_eid` - Source endpoint ID (unused)
-///
-/// # Returns
-/// The amount credited
-pub fn credit<T: OFTCore>(env: &Env, token: &Address, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
-    TokenClient::new(env, token).transfer(&env.current_contract_address(), to, &amount_ld);
-    amount_ld
-}

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

@@ -1,51 +0,0 @@
-//! MintBurn type implementation for OFT.
-//!
-//! This OFT type burns tokens on debit (send) and mints tokens on credit (receive).
-//! 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;
-use soroban_sdk::{token::TokenClient, Address, Env};
-
-/// Debit tokens using MintBurn OFT type (burns tokens from sender).
-///
-/// # Parameters
-/// * `env` - The Soroban environment
-/// * `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)
-/// * `dst_eid` - Destination endpoint ID
-///
-/// # Returns
-/// * `amount_sent_ld` - The amount sent in local decimals
-/// * `amount_received_ld` - The amount received in local decimals on the remote
-pub fn debit<T: OFTCore>(
-    env: &Env,
-    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);
-    TokenClient::new(env, token).burn(sender, &amount_received_ld);
-    (amount_sent_ld, amount_received_ld)
-}
-
-/// Credit tokens using MintBurn OFT type (mints tokens to recipient).
-///
-/// # Parameters
-/// * `env` - The Soroban environment
-/// * `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)
-///
-/// # Returns
-/// The amount credited
-pub fn credit<T: OFTCore>(env: &Env, mintable: &Address, to: &Address, amount_ld: i128, _src_eid: u32) -> i128 {
-    MintableClient::new(env, mintable).mint(to, &amount_ld, &env.current_contract_address());
-    amount_ld
-}

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

@@ -1,24 +0,0 @@
-//! OFT mode implementations.
-//!
-//! This module provides reference implementations for the two main OFT types:
-//!
-//! - **LockUnlock**: Locks tokens on send, unlocks on receive. Operates directly on the
-//!   token via standard SEP-41 `transfer`.
-//! - **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};
-
-pub mod lock_unlock;
-pub mod mint_burn;
-
-/// The OFT operation type.
-#[contracttype]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum OftType {
-    /// Lock tokens on send, unlock on receive.
-    LockUnlock,
-    /// Burn tokens on send, mint on receive.
-    /// The address is the Mintable contract used for minting on credit
-    MintBurn(Address),
-}

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

@@ -1,3 +0,0 @@
-mod oft_fee;
-mod pausable;
-mod rate_limiter;

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

@@ -1,260 +0,0 @@
-extern crate std;
-
-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},
-    token::{StellarAssetClient, TokenClient},
-    Address, Env, IntoVal, Symbol,
-};
-use utils::auth::Auth;
-use utils::rbac::{grant_role_no_auth, RoleBasedAccessControl};
-
-// ============================================================================
-// Test Contract
-// ============================================================================
-
-#[contract]
-struct FeeTestContract;
-
-impl Auth for FeeTestContract {
-    fn authorizer(env: &Env) -> Option<Address> {
-        Some(env.current_contract_address())
-    }
-}
-
-impl OFTFeeInternal for FeeTestContract {}
-
-#[contractimpl(contracttrait)]
-impl OFTFee for FeeTestContract {}
-
-#[contractimpl(contracttrait)]
-impl RoleBasedAccessControl for FeeTestContract {}
-
-#[contractimpl]
-impl FeeTestContract {
-    /// Test-only: grants FEE_CONFIG_MANAGER_ROLE to the contract.
-    pub fn init_roles(env: Env) {
-        let contract_id = env.current_contract_address();
-        grant_role_no_auth(&env, &contract_id, &Symbol::new(&env, FEE_CONFIG_MANAGER_ROLE), &contract_id);
-    }
-
-    pub fn fee_view(env: Env, dst_eid: u32, amount_ld: i128) -> i128 {
-        <Self as OFTFeeInternal>::__fee_view(&env, dst_eid, amount_ld)
-    }
-
-    pub fn charge_fee(env: Env, token: Address, from: Address, fee_amount: i128) {
-        <Self as OFTFeeInternal>::__charge_fee(&env, &token, &from, fee_amount)
-    }
-}
-
-// ============================================================================
-// Test Setup
-// ============================================================================
-
-struct TestSetup {
-    env: Env,
-    client: FeeTestContractClient<'static>,
-    contract_id: Address,
-    token: Address,
-    from: Address,
-    fee_deposit: 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 contract_id = env.register(FeeTestContract, ());
-    let client = FeeTestContractClient::new(&env, &contract_id);
-    client.init_roles();
-
-    let token_admin = Address::generate(&env);
-    let sac = env.register_stellar_asset_contract_v2(token_admin.clone());
-    let token = sac.address();
-
-    let from = Address::generate(&env);
-    let fee_deposit = Address::generate(&env);
-
-    // Mint to `from` - auth is mocked globally
-    StellarAssetClient::new(&env, &token).mint(&from, &1_000_000i128);
-
-    TestSetup { env, client, contract_id, token, from, fee_deposit }
-}
-
-// ============================================================================
-// Fee View Tests
-// ============================================================================
-
-#[test]
-fn test_fee_view_zero_fee_returns_zero() {
-    let TestSetup { client, .. } = setup();
-
-    let fee = client.fee_view(&1u32, &1_000_000i128);
-    assert_eq!(fee, 0);
-}
-
-#[test]
-fn test_fee_deposit_address_returns_none_when_unset() {
-    let TestSetup { client, .. } = setup();
-
-    assert_eq!(client.fee_deposit_address(), None);
-}
-
-#[test]
-fn test_fee_view_nonzero_fee_errors_when_deposit_address_unset() {
-    let TestSetup { client, contract_id, .. } = setup();
-
-    client.set_default_fee_bps(&Some(100u32), &contract_id);
-
-    let res = client.try_fee_view(&7u32, &1_000_000i128);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeDepositAddress.into());
-}
-
-// ============================================================================
-// Set Default Fee BPS Tests
-// ============================================================================
-
-#[test]
-fn test_set_default_fee_bps_rejects_invalid_value() {
-    let TestSetup { client, contract_id, .. } = setup();
-
-    // Zero is not a valid default fee (use None to remove instead)
-    let res = client.try_set_default_fee_bps(&Some(0u32), &contract_id);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
-
-    // Exceeds maximum
-    let res = client.try_set_default_fee_bps(&Some(10_001u32), &contract_id);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
-}
-
-#[test]
-fn test_set_default_fee_bps_rejects_same_value() {
-    let TestSetup { client, contract_id, .. } = setup();
-
-    // None when already None (not set)
-    let none: Option<u32> = None;
-    let res = client.try_set_default_fee_bps(&none, &contract_id);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
-
-    // Same value when already set
-    client.set_default_fee_bps(&Some(123u32), &contract_id);
-    let res2 = client.try_set_default_fee_bps(&Some(123u32), &contract_id);
-    assert_eq!(res2.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
-}
-
-// ============================================================================
-// Set Fee BPS Tests
-// ============================================================================
-
-#[test]
-fn test_set_fee_bps_rejects_invalid_and_same_value() {
-    let TestSetup { client, contract_id, .. } = setup();
-    let dst_eid = 101u32;
-
-    let res = client.try_set_fee_bps(&dst_eid, &None, &contract_id);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
-
-    let res2 = client.try_set_fee_bps(&dst_eid, &Some(10_001u32), &contract_id);
-    assert_eq!(res2.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
-}
-
-#[test]
-fn test_set_fee_bps_set_and_remove() {
-    let TestSetup { client, contract_id, .. } = setup();
-    let dst_eid = 101u32;
-
-    client.set_fee_bps(&dst_eid, &Some(200u32), &contract_id);
-    assert_eq!(client.fee_bps(&dst_eid), Some(200u32));
-    assert_eq!(client.effective_fee_bps(&dst_eid), 200u32);
-
-    client.set_default_fee_bps(&Some(111u32), &contract_id);
-    client.set_fee_bps(&dst_eid, &None, &contract_id);
-    assert_eq!(client.fee_bps(&dst_eid), None);
-    assert_eq!(client.effective_fee_bps(&dst_eid), 111u32);
-}
-
-// ============================================================================
-// Charge Fee Tests
-// ============================================================================
-
-#[test]
-fn test_charge_fee_errors_without_deposit_address() {
-    let TestSetup { env, client, contract_id, token, from, .. } = setup();
-
-    // Mock auth for token transfer (will fail before transfer due to missing deposit address)
-    env.mock_auths(&[MockAuth {
-        address: &from,
-        invoke: &MockAuthInvoke {
-            contract: &contract_id,
-            fn_name: "charge_fee",
-            args: (&token, &from, &1i128).into_val(&env),
-            sub_invokes: &[MockAuthInvoke {
-                contract: &token,
-                fn_name: "transfer",
-                args: (&from, &Address::generate(&env), &1i128).into_val(&env),
-                sub_invokes: &[],
-            }],
-        },
-    }]);
-
-    let res = client.try_charge_fee(&token, &from, &1i128);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeDepositAddress.into());
-}
-
-#[test]
-fn test_set_fee_deposit_address_same_value() {
-    let TestSetup { client, contract_id, fee_deposit, .. } = setup();
-
-    let fee_deposit_opt = Some(fee_deposit);
-    client.set_fee_deposit_address(&fee_deposit_opt, &contract_id);
-    let res = client.try_set_fee_deposit_address(&fee_deposit_opt, &contract_id);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
-}
-
-#[test]
-fn test_charge_fee_zero_amount_no_transfer() {
-    let TestSetup { env, client, contract_id, token, from, fee_deposit, .. } = setup();
-
-    client.set_fee_deposit_address(&Some(fee_deposit.clone()), &contract_id);
-
-    let token_client = TokenClient::new(&env, &token);
-    let from_before = token_client.balance(&from);
-    let dep_before = token_client.balance(&fee_deposit);
-
-    // fee_amount == 0 => no transfer
-    client.charge_fee(&token, &from, &0i128);
-
-    assert_eq!(token_client.balance(&from), from_before);
-    assert_eq!(token_client.balance(&fee_deposit), dep_before);
-}
-
-#[test]
-fn test_charge_fee_transfers() {
-    let TestSetup { env, client, contract_id, token, from, fee_deposit, .. } = setup();
-
-    client.set_fee_deposit_address(&Some(fee_deposit.clone()), &contract_id);
-
-    let token_client = TokenClient::new(&env, &token);
-    let from_before = token_client.balance(&from);
-    let dep_before = token_client.balance(&fee_deposit);
-
-    client.charge_fee(&token, &from, &123i128);
-
-    assert_eq!(token_client.balance(&from), from_before - 123);
-    assert_eq!(token_client.balance(&fee_deposit), dep_before + 123);
-}
-
-#[test]
-fn test_fee_view_computes_correct_fee() {
-    let TestSetup { client, contract_id, fee_deposit, .. } = setup();
-
-    client.set_fee_deposit_address(&Some(fee_deposit), &contract_id);
-    client.set_default_fee_bps(&Some(100u32), &contract_id); // 1%
-
-    let fee = client.fee_view(&999u32, &10_000i128);
-    assert_eq!(fee, 100); // 1% of 10,000
-}