@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/oapp-macros/src/util.rs

@@ -1,107 +0,0 @@
-use proc_macro::TokenStream;
-use proc_macro2::Ident;
-use syn::{
-    parse::{Parse, ParseStream},
-    punctuated::Punctuated,
-    Error, ItemStruct, Token,
-};
-
-/// Configuration for which OApp trait implementations should be manually provided by the user.
-///
-/// This struct is parsed from the `#[oapp_manual_impl(...)]` attribute and controls
-/// which default trait implementations are generated by the macros.
-///
-/// # Fields
-/// * `core` - If `true`, the user must manually implement `OAppCore`
-/// * `sender` - If `true`, the user must manually implement `OAppSender`
-/// * `receiver` - If `true`, the user must manually implement `OAppReceiver` trait entirely
-/// * `options_type3` - If `true`, the user must manually implement `OAppOptionsType3`
-///
-/// # Receiver Manual Implementation
-/// When `receiver` is `true`, the macro will NOT generate `impl OAppReceiver`. The user
-/// must manually implement the entire `OAppReceiver` trait, including `lz_receive`,
-/// `next_nonce`, `allow_initialize_path`, and `is_compose_msg_sender`.
-///
-/// This is useful when you need to customize methods like `next_nonce` (e.g., for ordered delivery).
-#[derive(Debug, Clone, Copy, Default)]
-pub struct ManualImplConfig {
-    pub core: bool,
-    pub sender: bool,
-    pub receiver: bool,
-    pub options_type3: bool,
-}
-
-impl ManualImplConfig {
-    /// Parses configuration from the `#[oapp_manual_impl(...)]` attribute arguments.
-    ///
-    /// Accepts a comma-separated list of identifiers: `core`, `sender`, `receiver`, `options_type3`.
-    /// Returns an error if any invalid identifier is provided.
-    fn from_attr(input: ParseStream) -> syn::Result<Self> {
-        let idents = Punctuated::<syn::Ident, Token![,]>::parse_terminated(input)?;
-
-        let mut cfg = ManualImplConfig::default();
-
-        for ident in idents {
-            match ident.to_string().as_str() {
-                "core" => cfg.core = true,
-                "sender" => cfg.sender = true,
-                "receiver" => cfg.receiver = true,
-                "options_type3" => cfg.options_type3 = true,
-                _ => {
-                    return Err(Error::new(
-                        ident.span(),
-                        "invalid value for oapp_manual_impl: expected one of `core`, `sender`, `receiver`, `options_type3`",
-                    ));
-                }
-            }
-        }
-
-        Ok(cfg)
-    }
-}
-
-impl Parse for ManualImplConfig {
-    fn parse(input: ParseStream) -> syn::Result<Self> {
-        ManualImplConfig::from_attr(input)
-    }
-}
-
-/// Parses a struct definition and extracts manual implementation configuration.
-///
-/// This function is used by all OApp macros to:
-/// 1. Parse the annotated item as a struct
-/// 2. Extract the struct name
-/// 3. Parse any `#[oapp_manual_impl(...)]` attributes to determine configuration
-///
-/// # Returns
-/// A tuple containing:
-/// * The struct identifier
-/// * The complete struct definition
-/// * The manual implementation configuration
-///
-/// # Errors
-/// Returns a compile error if:
-/// * The item is not a struct
-/// * The `#[oapp_manual_impl(...)]` attribute has invalid syntax
-pub fn parse_struct(item: TokenStream) -> Result<(Ident, ItemStruct, ManualImplConfig), TokenStream> {
-    let item_struct = syn::parse::<ItemStruct>(item).map_err(|e| e.to_compile_error())?;
-    let name = item_struct.ident.clone();
-
-    let mut cfg = ManualImplConfig::default();
-    // TODO: match at most once oapp_manual_impl attribute
-    for attr in item_struct.attrs.iter() {
-        if attr.path().is_ident("oapp_manual_impl") {
-            match attr.parse_args::<ManualImplConfig>() {
-                Ok(parsed) => {
-                    cfg = parsed;
-                }
-                Err(e) => {
-                    return Err(e.to_compile_error().into());
-                }
-            }
-            break;
-        }
-    }
-
-    Ok((name, item_struct, cfg))
-}

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

@@ -1,5 +0,0 @@
-/// Message type for simple OFT send
-pub const SEND: u32 = 1;
-
-/// Message type for OFT send with compose functionality
-pub const SEND_AND_CALL: u32 = 2;

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

@@ -1,146 +0,0 @@
-//! Default OFT implementations.
-//!
-//! This module provides default standalone functions for common OFT operations that can be
-//! reused by trait implementations.
-
-use crate::{
-    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec::OFTMessage},
-    constants,
-    errors::OFTError,
-    events,
-    events::OFTSent,
-    storage::OFTStorage,
-    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
-    utils::{address_to_bytes32, remove_dust, resolve_address, to_ld, to_sd},
-};
-use endpoint_v2::{MessagingComposerClient, MessagingFee, MessagingReceipt, Origin};
-use oapp::oapp_options_type3::OAppOptionsType3;
-use soroban_sdk::{assert_with_error, vec, Address, Bytes, BytesN, Env, Vec};
-
-/// Calculates debit amounts without executing (view function).
-pub fn default_debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, _dst_eid: u32) -> OFTReceipt {
-    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
-    let amount_sent_ld = remove_dust(amount_ld, conversion_rate);
-    let amount_received_ld = amount_sent_ld;
-
-    assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
-
-    OFTReceipt { amount_sent_ld, amount_received_ld }
-}
-
-/// Builds OFT message and combines options for cross-chain transfer.
-pub fn default_build_msg_and_options<T>(
-    env: &Env,
-    sender: &Address,
-    send_param: &SendParam,
-    amount_ld: i128,
-) -> (Bytes, Bytes)
-where
-    T: OAppOptionsType3,
-{
-    let has_compose = !send_param.compose_msg.is_empty();
-    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
-    let msg = OFTMessage {
-        send_to: send_param.to.clone(),
-        amount_sd: to_sd(env, amount_ld, conversion_rate),
-        compose_from: if has_compose { Some(address_to_bytes32(sender)) } else { None },
-        compose_msg: if has_compose { Some(send_param.compose_msg.clone()) } else { None },
-    };
-    let (msg, _) = msg.encode(env);
-    let msg_type = if has_compose { constants::SEND_AND_CALL } else { constants::SEND };
-
-    (msg, T::combine_options(env, send_param.dst_eid, msg_type, &send_param.extra_options))
-}
-
-/// Handles OFT receive logic.
-pub fn default_lz_receive<T>(
-    env: &Env,
-    _executor: &Address,
-    origin: &Origin,
-    guid: &BytesN<32>,
-    message: &Bytes,
-    _extra_data: &Bytes,
-    _value: i128,
-) where
-    T: crate::oft::OFTInner,
-{
-    let oft_msg = OFTMessage::decode(message);
-    let send_to = resolve_address(env, &oft_msg.send_to);
-
-    let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
-    let amount_received_ld = T::__credit(env, &send_to, to_ld(oft_msg.amount_sd, conversion_rate), origin.src_eid);
-
-    if oft_msg.is_composed() {
-        let compose_msg = OFTComposeMsg {
-            nonce: origin.nonce,
-            src_eid: origin.src_eid,
-            amount_ld: amount_received_ld,
-            compose_from: oft_msg.compose_from.unwrap(),
-            compose_msg: oft_msg.compose_msg.unwrap(),
-        }
-        .encode(env);
-
-        let endpoint = MessagingComposerClient::new(env, &T::endpoint(env));
-        endpoint.send_compose(&env.current_contract_address(), &send_to, guid, &0, &compose_msg);
-    }
-
-    events::OFTReceived { guid: guid.clone(), src_eid: origin.src_eid, to: send_to, amount_received_ld }.publish(env);
-}
-
-/// Quotes an OFT transfer without executing.
-/// Returns (OFTLimit, fee details, receipt with estimated amounts).
-pub fn default_quote_oft<T>(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt)
-where
-    T: crate::oft::OFTInner,
-{
-    let oft_receipt = T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
-    let oft_fee_details = if oft_receipt.amount_sent_ld > oft_receipt.amount_received_ld {
-        vec![env, OFTFeeDetail { fee_amount_ld: oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld, description: Bytes::from_array(env, b"OFT Fee") }]
-    } else {
-        vec![env]
-    };
-    (OFTLimit { min_amount_ld: 0, max_amount_ld: i128::MAX }, oft_fee_details, oft_receipt)
-}
-
-/// Quotes a send operation including LayerZero messaging fees.
-pub fn default_quote_send<T>(env: &Env, sender: &Address, send_param: &SendParam, pay_in_zro: bool) -> MessagingFee
-where
-    T: crate::oft::OFT,
-{
-    let OFTReceipt { amount_received_ld, .. } =
-        T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
-
-    let (msg, options) = default_build_msg_and_options::<T>(env, sender, send_param, amount_received_ld);
-    T::lz_quote(env, send_param.dst_eid, &msg, &options, pay_in_zro)
-}
-
-/// Sends tokens cross-chain to another endpoint.
-/// Sender must be authenticated. Returns (MessagingReceipt, OFTReceipt).
-pub fn default_send<T>(
-    env: &Env,
-    sender: &Address,
-    send_param: &SendParam,
-    fee: &MessagingFee,
-    refund_address: &Address,
-) -> (MessagingReceipt, OFTReceipt)
-where
-    T: crate::oft::OFT,
-{
-    sender.require_auth();
-
-    let oft_receipt = T::__debit(env, sender, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
-
-    let (msg, options) = default_build_msg_and_options::<T>(env, sender, send_param, oft_receipt.amount_received_ld);
-    let msg_receipt = T::lz_send(env, sender, send_param.dst_eid, &msg, &options, fee, refund_address);
-
-    OFTSent {
-        guid: msg_receipt.guid.clone(),
-        dst_eid: send_param.dst_eid,
-        from: sender.clone(),
-        amount_sent_ld: oft_receipt.amount_sent_ld,
-        amount_received_ld: oft_receipt.amount_received_ld,
-    }
-    .publish(env);
-
-    (msg_receipt, oft_receipt)
-}

package/contracts/utils/src/tests/ttl.rs

@@ -1,421 +0,0 @@
-extern crate std;
-
-use crate::errors::TtlError;
-use crate::ttl::{
-    DefaultTtlConfigurable, TtlConfig, TtlConfigStorage, TtlConfigurable, DEFAULT_INSTANCE_TTL, DEFAULT_PERSISTENT_TTL,
-    MAX_TTL,
-};
-use soroban_sdk::{contract, contractimpl, Address, Env};
-
-// ============================================
-// Test Contract for TTL functionality
-// ============================================
-
-#[contract]
-pub struct TtlTestContract;
-
-#[contractimpl]
-impl TtlTestContract {
-    // TtlConfigStorage storage tests
-    pub fn frozen(env: &Env) -> bool {
-        TtlConfigStorage::frozen(env)
-    }
-
-    pub fn set_frozen(env: &Env, value: bool) {
-        TtlConfigStorage::set_frozen(env, &value);
-    }
-
-    pub fn instance_ttl(env: &Env) -> TtlConfig {
-        TtlConfigStorage::instance(env).unwrap_or(DEFAULT_INSTANCE_TTL)
-    }
-
-    pub fn set_instance_ttl(env: &Env, config: TtlConfig) {
-        TtlConfigStorage::set_instance(env, &config);
-    }
-
-    pub fn has_instance_ttl(env: &Env) -> bool {
-        TtlConfigStorage::has_instance(env)
-    }
-
-    pub fn remove_instance_ttl(env: &Env) {
-        TtlConfigStorage::remove_instance(env);
-    }
-
-    pub fn remove_persistent_ttl(env: &Env) {
-        TtlConfigStorage::remove_persistent(env);
-    }
-
-    pub fn persistent_ttl(env: &Env) -> TtlConfig {
-        TtlConfigStorage::persistent(env).unwrap_or(DEFAULT_PERSISTENT_TTL)
-    }
-
-    pub fn set_persistent_ttl(env: &Env, config: TtlConfig) {
-        TtlConfigStorage::set_persistent(env, &config);
-    }
-
-    pub fn has_persistent_ttl(env: &Env) -> bool {
-        TtlConfigStorage::has_persistent(env)
-    }
-
-    // DefaultTtlConfigurable tests
-    pub fn configurable_set_ttl_configs(env: &Env, instance: Option<TtlConfig>, persistent: Option<TtlConfig>) {
-        DefaultTtlConfigurable::set_ttl_configs(env, &instance, &persistent);
-    }
-
-    pub fn configurable_ttl_configs(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>) {
-        DefaultTtlConfigurable::ttl_configs(env)
-    }
-
-    pub fn configurable_freeze_ttl_configs(env: &Env) {
-        DefaultTtlConfigurable::freeze_ttl_configs(env);
-    }
-
-    pub fn is_ttl_configs_frozen(env: &Env) -> bool {
-        DefaultTtlConfigurable::is_ttl_configs_frozen(env)
-    }
-}
-
-fn setup_contract() -> (Env, Address, TtlTestContractClient<'static>) {
-    let env = Env::default();
-    let contract_id = env.register(TtlTestContract, ());
-    let client = TtlTestContractClient::new(&env, &contract_id);
-    (env, contract_id, client)
-}
-
-// ============================================
-// TtlConfig Struct Tests
-// ============================================
-
-#[test]
-fn test_ttl_config_new() {
-    let config = TtlConfig::new(100, 200);
-    assert_eq!(config.threshold, 100);
-    assert_eq!(config.extend_to, 200);
-}
-
-#[test]
-fn test_ttl_config_is_valid() {
-    // Valid configs
-    assert!(TtlConfig::new(100, 200).is_valid(300)); // threshold < extend_to < max
-    assert!(TtlConfig::new(100, 100).is_valid(200)); // threshold == extend_to
-    assert!(TtlConfig::new(100, 200).is_valid(200)); // extend_to == max
-    assert!(TtlConfig::new(100, 100).is_valid(100)); // all equal
-    assert!(TtlConfig::new(0, 0).is_valid(0)); // all zeros
-    assert!(TtlConfig::new(0, 0).is_valid(100)); // zero config with non-zero max
-    assert!(TtlConfig::new(0, 100).is_valid(100)); // threshold at minimum
-    assert!(TtlConfig::new(99, 100).is_valid(100)); // threshold just below extend_to
-    assert!(TtlConfig::new(MAX_TTL - 1, MAX_TTL).is_valid(MAX_TTL)); // large values
-    assert!(TtlConfig::new(MAX_TTL, MAX_TTL).is_valid(MAX_TTL)); // max values
-
-    // Invalid configs
-    assert!(!TtlConfig::new(200, 100).is_valid(300)); // threshold > extend_to
-    assert!(!TtlConfig::new(100, 400).is_valid(300)); // extend_to > max
-    assert!(!TtlConfig::new(100, 100).is_valid(99)); // extend_to > max
-}
-
-#[test]
-fn test_default_ttl_configs_are_valid() {
-    assert!(DEFAULT_INSTANCE_TTL.is_valid(MAX_TTL));
-    assert!(DEFAULT_PERSISTENT_TTL.is_valid(MAX_TTL));
-}
-
-// ============================================
-// TtlConfigStorage Storage Tests
-// ============================================
-
-#[test]
-fn test_ttl_config_data_defaults() {
-    let (_, _, client) = setup_contract();
-
-    // Default frozen state should be false
-    assert!(!client.frozen());
-
-    // Default TTLs should be returned when not set
-    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-
-    // has_* should return false initially
-    assert!(!client.has_instance_ttl());
-    assert!(!client.has_persistent_ttl());
-}
-
-#[test]
-fn test_ttl_config_data_set_get_remove() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-    let persistent_cfg = TtlConfig::new(3000, 4000);
-
-    // Set and verify instance
-    client.set_instance_ttl(&instance_cfg);
-    assert!(client.has_instance_ttl());
-    assert_eq!(client.instance_ttl(), instance_cfg);
-
-    // Set and verify persistent
-    client.set_persistent_ttl(&persistent_cfg);
-    assert!(client.has_persistent_ttl());
-    assert_eq!(client.persistent_ttl(), persistent_cfg);
-
-    // Remove and verify defaults return
-    client.remove_instance_ttl();
-    assert!(!client.has_instance_ttl());
-    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
-
-    // Remove persistent
-    client.remove_persistent_ttl();
-    assert!(!client.has_persistent_ttl());
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-}
-
-#[test]
-fn test_ttl_config_data_frozen() {
-    let (_, _, client) = setup_contract();
-
-    assert!(!client.frozen());
-
-    client.set_frozen(&true);
-    assert!(client.frozen());
-
-    client.set_frozen(&false);
-    assert!(!client.frozen());
-}
-
-#[test]
-fn test_ttl_config_data_independent_storage() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(100, 200);
-    let persistent_cfg = TtlConfig::new(300, 400);
-
-    // Set each independently and verify others unchanged
-    client.set_instance_ttl(&instance_cfg);
-    assert_eq!(client.instance_ttl(), instance_cfg);
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-
-    client.set_persistent_ttl(&persistent_cfg);
-    assert_eq!(client.instance_ttl(), instance_cfg);
-    assert_eq!(client.persistent_ttl(), persistent_cfg);
-}
-
-#[test]
-fn test_ttl_config_data_remove_all() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-    let persistent_cfg = TtlConfig::new(3000, 4000);
-
-    // Set all configs
-    client.set_instance_ttl(&instance_cfg);
-    client.set_persistent_ttl(&persistent_cfg);
-
-    // Verify all are set
-    assert!(client.has_instance_ttl());
-    assert!(client.has_persistent_ttl());
-
-    // Remove all
-    client.remove_instance_ttl();
-    client.remove_persistent_ttl();
-
-    // Verify all return to defaults
-    assert!(!client.has_instance_ttl());
-    assert!(!client.has_persistent_ttl());
-    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-}
-
-#[test]
-fn test_ttl_config_data_remove_when_not_set() {
-    let (_, _, client) = setup_contract();
-
-    // Removing when not set should not panic
-    client.remove_instance_ttl();
-    client.remove_persistent_ttl();
-
-    // Should still return defaults
-    assert_eq!(client.instance_ttl(), DEFAULT_INSTANCE_TTL);
-    assert_eq!(client.persistent_ttl(), DEFAULT_PERSISTENT_TTL);
-}
-
-// ============================================
-// DefaultTtlConfigurable Tests - Basic Operations
-// ============================================
-
-#[test]
-fn test_default_ttl_configurable_initial_state() {
-    let (_, _, client) = setup_contract();
-
-    let (instance, persistent) = client.configurable_ttl_configs();
-    assert!(instance.is_none());
-    assert!(persistent.is_none());
-
-    assert!(!client.is_ttl_configs_frozen());
-}
-
-#[test]
-fn test_default_ttl_configurable_set_all() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-    let persistent_cfg = TtlConfig::new(3000, 4000);
-
-    client.configurable_set_ttl_configs(&Some(instance_cfg), &Some(persistent_cfg));
-
-    let (instance, persistent) = client.configurable_ttl_configs();
-    assert_eq!(instance, Some(instance_cfg));
-    assert_eq!(persistent, Some(persistent_cfg));
-}
-
-#[test]
-fn test_default_ttl_configurable_set_partial() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-
-    // Only set instance config
-    client.configurable_set_ttl_configs(&Some(instance_cfg), &None);
-
-    let (instance, persistent) = client.configurable_ttl_configs();
-    assert_eq!(instance, Some(instance_cfg));
-    assert!(persistent.is_none());
-}
-
-#[test]
-fn test_default_ttl_configurable_set_and_remove() {
-    let (_, _, client) = setup_contract();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-
-    // Set config
-    client.configurable_set_ttl_configs(&Some(instance_cfg), &None);
-    assert_eq!(client.configurable_ttl_configs().0, Some(instance_cfg));
-
-    // Remove by passing None
-    client.configurable_set_ttl_configs(&None, &None);
-    assert!(client.configurable_ttl_configs().0.is_none());
-}
-
-// ============================================
-// DefaultTtlConfigurable Tests - Freeze Operations
-// ============================================
-
-#[test]
-fn test_default_ttl_configurable_freeze() {
-    let (_, _, client) = setup_contract();
-
-    assert!(!client.is_ttl_configs_frozen());
-    client.configurable_freeze_ttl_configs();
-    assert!(client.is_ttl_configs_frozen());
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1201)")]
-fn test_default_ttl_configurable_set_when_frozen() {
-    let (_, _, client) = setup_contract();
-
-    client.configurable_freeze_ttl_configs();
-
-    let instance_cfg = TtlConfig::new(1000, 2000);
-    client.configurable_set_ttl_configs(&Some(instance_cfg), &None);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1202)")]
-fn test_default_ttl_configurable_freeze_when_already_frozen() {
-    let (_, _, client) = setup_contract();
-
-    client.configurable_freeze_ttl_configs();
-    client.configurable_freeze_ttl_configs();
-}
-
-// ============================================
-// DefaultTtlConfigurable Tests - Validation
-// ============================================
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
-fn test_default_ttl_configurable_invalid_instance_config() {
-    let (_, _, client) = setup_contract();
-    // threshold > extend_to is invalid
-    let invalid_cfg = TtlConfig::new(3000, 2000);
-    client.configurable_set_ttl_configs(&Some(invalid_cfg), &None);
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
-fn test_default_ttl_configurable_invalid_persistent_config() {
-    let (_, _, client) = setup_contract();
-    let invalid_cfg = TtlConfig::new(5000, 4000);
-    client.configurable_set_ttl_configs(&None, &Some(invalid_cfg));
-}
-
-#[test]
-#[should_panic(expected = "Error(Contract, #1200)")]
-fn test_default_ttl_configurable_exceeds_max_ttl() {
-    let (_, _, client) = setup_contract();
-    let invalid_cfg = TtlConfig::new(1000, MAX_TTL + 1);
-    client.configurable_set_ttl_configs(&Some(invalid_cfg), &None);
-}
-
-#[test]
-fn test_default_ttl_configurable_invalid_does_not_partially_update() {
-    let (_, _, client) = setup_contract();
-
-    // Seed with an initial valid state.
-    let before_instance = TtlConfig::new(1000, 2000);
-    let before_persistent = TtlConfig::new(3000, 4000);
-    client.configurable_set_ttl_configs(&Some(before_instance), &Some(before_persistent));
-    assert_eq!(client.configurable_ttl_configs(), (Some(before_instance), Some(before_persistent)));
-
-    // Attempt to update with one invalid config and one different valid config.
-    // This must fail and must not partially apply any changes.
-    let invalid_instance = TtlConfig::new(3000, 2000); // threshold > extend_to
-    let next_persistent = TtlConfig::new(3100, 4100);
-    assert_eq!(
-        client.try_configurable_set_ttl_configs(&Some(invalid_instance), &Some(next_persistent)).unwrap_err().unwrap(),
-        TtlError::InvalidTtlConfig.into()
-    );
-
-    // Ensure nothing changed.
-    assert_eq!(client.configurable_ttl_configs(), (Some(before_instance), Some(before_persistent)));
-}
-
-// ============================================
-// DefaultTtlConfigurable Tests - Boundary Values
-// ============================================
-
-#[test]
-fn test_default_ttl_configurable_at_max_ttl() {
-    let (env, _, client) = setup_contract();
-
-    // Get the effective max TTL
-    let effective_max = u32::min(MAX_TTL, env.storage().max_ttl());
-
-    // extend_to == effective_max should be valid
-    let valid_cfg = TtlConfig::new(1000, effective_max);
-    client.configurable_set_ttl_configs(&Some(valid_cfg), &None);
-
-    let (instance, _) = client.configurable_ttl_configs();
-    assert_eq!(instance, Some(valid_cfg));
-}
-
-#[test]
-fn test_default_ttl_configurable_boundary_values() {
-    let (env, _, client) = setup_contract();
-
-    let effective_max = u32::min(MAX_TTL, env.storage().max_ttl());
-
-    // Zero threshold and extend_to
-    let cfg = TtlConfig::new(0, 0);
-    client.configurable_set_ttl_configs(&Some(cfg), &None);
-    assert_eq!(client.configurable_ttl_configs().0, Some(cfg));
-
-    // Zero threshold, max extend_to
-    let cfg = TtlConfig::new(0, effective_max);
-    client.configurable_set_ttl_configs(&Some(cfg), &None);
-    assert_eq!(client.configurable_ttl_configs().0, Some(cfg));
-
-    // Equal threshold and extend_to
-    let cfg = TtlConfig::new(1000, 1000);
-    client.configurable_set_ttl_configs(&Some(cfg), &None);
-    assert_eq!(client.configurable_ttl_configs().0, Some(cfg));
-}