@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

package/contracts/common-macros/src/tests/rbac.rs

@@ -1,523 +0,0 @@
-use proc_macro2::TokenStream;
-use quote::quote;
-
-use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
-
-// ============================================
-// Snapshot Test: has_role and only_role
-// ============================================
-
-#[test]
-fn snapshot_preserve_function_signature() {
-    let args = quote! { caller, "minter" };
-    let input = quote! {
-        pub fn mint(env: Env, caller: Address, amount: i128) {
-            // mint logic
-        }
-    };
-
-    let has_role_result = crate::rbac::generate_role_check(args.clone(), input.clone(), false);
-    let has_role_formatted =
-        prettyplease::unparse(&syn::parse2::<syn::File>(has_role_result).expect("failed to parse generated code"));
-
-    let only_role_result = crate::rbac::generate_role_check(args, input, true);
-    let only_role_formatted =
-        prettyplease::unparse(&syn::parse2::<syn::File>(only_role_result).expect("failed to parse generated code"));
-
-    let combined =
-        format!("// === has_role ===\n\n{}\n\n// === only_role ===\n\n{}", has_role_formatted, only_role_formatted);
-
-    insta::assert_snapshot!(combined);
-}
-
-// ============================================
-// generate_role_check assertion tests
-// ============================================
-
-fn assert_stmt_eq(stmt: &syn::Stmt, expected: &str, test_name: &str) {
-    let actual = quote::quote!(#stmt).to_string().replace(" ", "");
-    assert_eq!(actual, expected, "{test_name}: expected '{expected}', got '{actual}'");
-}
-
-fn assert_role_check_exact_stmts(
-    args: TokenStream,
-    input: TokenStream,
-    require_auth: bool,
-    expected_ensure_stmt_no_spaces: &str,
-    expected_auth_stmt_no_spaces: Option<&str>,
-    expected_stmt_count: Option<usize>,
-    test_name: &str,
-) -> syn::ItemFn {
-    let result_tokens = crate::rbac::generate_role_check(args, input, require_auth);
-    let output_fn: syn::ItemFn =
-        syn::parse2(result_tokens).unwrap_or_else(|e| panic!("{test_name}: failed to parse output function: {e}"));
-
-    assert!(!output_fn.block.stmts.is_empty(), "{test_name}: function body should contain at least one statement");
-
-    assert_stmt_eq(&output_fn.block.stmts[0], expected_ensure_stmt_no_spaces, test_name);
-
-    if let Some(expected_auth) = expected_auth_stmt_no_spaces {
-        assert!(output_fn.block.stmts.len() >= 2, "{test_name}: expected at least two statements");
-        assert_stmt_eq(&output_fn.block.stmts[1], expected_auth, test_name);
-    }
-
-    if let Some(expected_count) = expected_stmt_count {
-        assert_eq!(
-            output_fn.block.stmts.len(),
-            expected_count,
-            "{test_name}: expected {expected_count} statements, got {}",
-            output_fn.block.stmts.len()
-        );
-    }
-
-    output_fn
-}
-
-#[test]
-fn test_role_check_inserts_expected_statements_table_driven() {
-    struct Case {
-        name: &'static str,
-        args: TokenStream,
-        input: TokenStream,
-        require_auth: bool,
-        expected_ensure_stmt: &'static str,
-        expected_auth_stmt: Option<&'static str>,
-        expected_stmt_count: usize,
-    }
-
-    let cases = vec![
-        Case {
-            name: "has_role: Env ref + Address value",
-            args: quote! { caller, "minter" },
-            input: quote! { pub fn mint(env: &Env, caller: Address, amount: i128) {} },
-            require_auth: false,
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),&caller);",
-            expected_auth_stmt: None,
-            expected_stmt_count: 1,
-        },
-        Case {
-            name: "only_role: Env owned + Address value",
-            args: quote! { caller, "minter" },
-            input: quote! { pub fn mint(env: Env, caller: Address, amount: i128) {} },
-            require_auth: true,
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(&env,&soroban_sdk::Symbol::new(&env,\"minter\"),&caller);",
-            expected_auth_stmt: Some("caller.require_auth();"),
-            expected_stmt_count: 2,
-        },
-        Case {
-            name: "only_role: Env ref + Address value",
-            args: quote! { caller, "minter" },
-            input: quote! { pub fn mint(env: &Env, caller: Address, amount: i128) {} },
-            require_auth: true,
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),&caller);",
-            expected_auth_stmt: Some("caller.require_auth();"),
-            expected_stmt_count: 2,
-        },
-        Case {
-            name: "has_role: &Address param uses account directly",
-            args: quote! { account, "admin" },
-            input: quote! { pub fn admin_action(env: Env, account: &Address) {} },
-            require_auth: false,
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(&env,&soroban_sdk::Symbol::new(&env,\"admin\"),account);",
-            expected_auth_stmt: None,
-            expected_stmt_count: 1,
-        },
-    ];
-
-    for c in cases {
-        assert_role_check_exact_stmts(
-            c.args,
-            c.input,
-            c.require_auth,
-            c.expected_ensure_stmt,
-            c.expected_auth_stmt,
-            Some(c.expected_stmt_count),
-            c.name,
-        );
-    }
-}
-
-#[test]
-fn test_has_role_role_arg_variants_generate_expected_symbol_new_table_driven() {
-    struct Case {
-        name: &'static str,
-        args: TokenStream,
-        input: TokenStream,
-        expected_ensure_stmt: &'static str,
-    }
-
-    let cases = vec![
-        Case {
-            name: "role string literal passed to Symbol::new (Env ref)",
-            args: quote! { caller, "minter" },
-            input: quote! { pub fn mint(env: &Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),&caller);",
-        },
-        Case {
-            name: "role const expr passed to Symbol::new (Env ref)",
-            args: quote! { caller, MINTER_ROLE },
-            input: quote! { pub fn mint(env: &Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,MINTER_ROLE),&caller);",
-        },
-        Case {
-            name: "role const expr passed to Symbol::new (Env owned)",
-            args: quote! { caller, MINTER_ROLE },
-            input: quote! { pub fn mint(env: Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(&env,&soroban_sdk::Symbol::new(&env,MINTER_ROLE),&caller);",
-        },
-        Case {
-            name: "role path expr passed to Symbol::new",
-            args: quote! { caller, roles::MINTER_ROLE },
-            input: quote! { pub fn mint(env: &Env, caller: Address) {} },
-            expected_ensure_stmt:
-                "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,roles::MINTER_ROLE),&caller);",
-        },
-    ];
-
-    for c in cases {
-        assert_role_check_exact_stmts(c.args, c.input, false, c.expected_ensure_stmt, None, Some(1), c.name);
-    }
-}
-
-// ============================================
-// Error cases: invalid args (table-driven)
-// ============================================
-
-#[test]
-fn test_has_role_rejects_invalid_args_table_driven() {
-    struct Case {
-        name: &'static str,
-        args: TokenStream,
-        expected_substring: &'static str,
-    }
-
-    let input = quote! { pub fn mint(env: Env, caller: Address) {} };
-    let cases = vec![
-        Case {
-            name: "missing comma in args",
-            args: quote! { caller "minter" },
-            expected_substring: "failed to parse has_role/only_role args",
-        },
-        Case {
-            name: "missing role",
-            args: quote! { caller, },
-            expected_substring: "failed to parse has_role/only_role args",
-        },
-        Case {
-            name: "extra tokens in args",
-            args: quote! { caller, "minter", extra },
-            expected_substring: "failed to parse has_role/only_role args",
-        },
-    ];
-
-    for c in cases {
-        assert_panics_contains(c.name, c.expected_substring, || {
-            crate::rbac::generate_role_check(c.args.clone(), input.clone(), false);
-        });
-    }
-}
-
-// ============================================
-// Error cases: invalid function signature inputs (table-driven)
-// ============================================
-
-#[test]
-fn test_has_role_rejects_invalid_function_signature_table_driven() {
-    struct Case {
-        name: &'static str,
-        args: TokenStream,
-        input: TokenStream,
-        expected_substring: &'static str,
-    }
-
-    let args = quote! { caller, "minter" };
-    let cases = vec![
-        Case {
-            name: "no Env param",
-            args: args.clone(),
-            input: quote! { pub fn mint(caller: Address, amount: i128) {} },
-            expected_substring: "function must have an Env argument",
-        },
-        Case {
-            name: "param not in signature",
-            args: args.clone(),
-            input: quote! { pub fn mint(env: Env, account: Address, amount: i128) {} },
-            expected_substring: "not found in function signature",
-        },
-        Case {
-            name: "param not Address",
-            args: args.clone(),
-            input: quote! { pub fn mint(env: Env, caller: u32, amount: i128) {} },
-            expected_substring: "must be of type `Address` or `&Address`",
-        },
-        Case {
-            name: "wildcard Env pattern",
-            args: args.clone(),
-            input: quote! { pub fn mint(_: Env, caller: Address) {} },
-            expected_substring: "function must have an Env argument",
-        },
-        Case {
-            name: "tuple Env pattern",
-            args: args.clone(),
-            input: quote! { pub fn mint((env, _): (&Env, u32), caller: Address) { let _ = env; } },
-            expected_substring: "function must have an Env argument",
-        },
-        Case {
-            name: "struct Env pattern",
-            args: args.clone(),
-            input: quote! { pub fn mint(Env { .. }: Env, caller: Address) {} },
-            expected_substring: "function must have an Env argument",
-        },
-        Case {
-            name: "&&Address is invalid",
-            args: args.clone(),
-            input: quote! { pub fn mint(env: &Env, caller: &&Address) {} },
-            expected_substring: "must be of type `Address` or `&Address`",
-        },
-    ];
-
-    for c in cases {
-        assert_panics_contains(c.name, c.expected_substring, || {
-            crate::rbac::generate_role_check(c.args.clone(), c.input.clone(), false);
-        });
-    }
-}
-
-// ============================================
-// Error cases: non-function input
-// ============================================
-
-#[test]
-fn test_has_role_rejects_non_function_inputs() {
-    let args = quote! { caller, "minter" };
-    for (case, input) in filter_item_inputs_excluding_labels(&["function"]) {
-        assert_panics_contains(case, "failed to parse function", || {
-            crate::rbac::generate_role_check(args.clone(), input.clone(), false);
-        });
-    }
-}
-
-// ============================================
-// High-value coverage: Env + Address + role variants (table-driven)
-// ============================================
-
-#[test]
-fn test_has_role_env_variants_generate_correct_env_ref_in_ensure_role() {
-    struct Case {
-        name: &'static str,
-        input: TokenStream,
-        expected_ensure_stmt: &'static str,
-    }
-
-    // Role is a literal so we also validate Symbol::new uses the same env_ref form.
-    let args = quote! { caller, "minter" };
-
-    let cases = vec![
-        Case {
-            name: "owned Env",
-            input: quote! { pub fn mint(env: Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(&env,&soroban_sdk::Symbol::new(&env,\"minter\"),&caller);",
-        },
-        Case {
-            name: "ref Env",
-            input: quote! { pub fn mint(env: &Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),&caller);",
-        },
-        Case {
-            name: "mut ref Env",
-            input: quote! { pub fn mint(env: &mut Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),&caller);",
-        },
-        Case {
-            name: "qualified owned Env",
-            input: quote! { pub fn mint(env: soroban_sdk::Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(&env,&soroban_sdk::Symbol::new(&env,\"minter\"),&caller);",
-        },
-        Case {
-            name: "qualified ref Env",
-            input: quote! { pub fn mint(env: &soroban_sdk::Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),&caller);",
-        },
-        Case {
-            name: "leading :: qualified owned Env",
-            input: quote! { pub fn mint(env: ::soroban_sdk::Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(&env,&soroban_sdk::Symbol::new(&env,\"minter\"),&caller);",
-        },
-    ];
-
-    for c in cases {
-        assert_role_check_exact_stmts(args.clone(), c.input, false, c.expected_ensure_stmt, None, Some(1), c.name);
-    }
-}
-
-#[test]
-fn test_has_role_address_variants_generate_correct_param_reference() {
-    struct Case {
-        name: &'static str,
-        input: TokenStream,
-        expected_ensure_stmt: &'static str,
-    }
-
-    let args = quote! { caller, "minter" };
-
-    let cases = vec![
-        Case {
-            name: "Address by value -> &caller",
-            input: quote! { pub fn mint(env: &Env, caller: Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),&caller);",
-        },
-        Case {
-            name: "&Address -> caller",
-            input: quote! { pub fn mint(env: &Env, caller: &Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),caller);",
-        },
-        Case {
-            name: "&mut Address -> caller",
-            input: quote! { pub fn mint(env: &Env, caller: &mut Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),caller);",
-        },
-        Case {
-            name: "qualified Address by value",
-            input: quote! { pub fn mint(env: &Env, caller: soroban_sdk::Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),&caller);",
-        },
-        Case {
-            name: "qualified &Address",
-            input: quote! { pub fn mint(env: &Env, caller: &soroban_sdk::Address) {} },
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,\"minter\"),caller);",
-        },
-    ];
-
-    for c in cases {
-        assert_role_check_exact_stmts(args.clone(), c.input, false, c.expected_ensure_stmt, None, Some(1), c.name);
-    }
-}
-
-#[test]
-fn test_only_role_inserts_expected_statements_and_preserves_original_body() {
-    let args = quote! { caller, "minter" };
-    let input = quote! {
-        pub fn mint(env: Env, caller: Address) {
-            let x = 1u32;
-            let _ = x + 1;
-        }
-    };
-
-    let output_fn = assert_role_check_exact_stmts(
-        args,
-        input,
-        true,
-        "utils::rbac::ensure_role::<Self>(&env,&soroban_sdk::Symbol::new(&env,\"minter\"),&caller);",
-        Some("caller.require_auth();"),
-        Some(4),
-        "only_role inserts ensure_role + require_auth",
-    );
-
-    // Ensure original statements remain after the inserted checks.
-    let third_stmt = &output_fn.block.stmts[2];
-    let third_stmt_str = quote::quote!(#third_stmt).to_string().replace(" ", "");
-    assert!(third_stmt_str.starts_with("letx=1u32;"), "expected original 'let x = 1u32;' to be preserved");
-}
-
-// ============================================
-// AUTHORIZER: snapshot test
-// ============================================
-
-#[test]
-fn snapshot_authorizer_role() {
-    let args = quote! { operator, AUTHORIZER };
-    let input = quote! {
-        pub fn admin_action(env: Env, operator: Address) {
-            // admin logic
-        }
-    };
-
-    let has_role_result = crate::rbac::generate_role_check(args.clone(), input.clone(), false);
-    let has_role_formatted =
-        prettyplease::unparse(&syn::parse2::<syn::File>(has_role_result).expect("failed to parse generated code"));
-
-    let only_role_result = crate::rbac::generate_role_check(args, input, true);
-    let only_role_formatted =
-        prettyplease::unparse(&syn::parse2::<syn::File>(only_role_result).expect("failed to parse generated code"));
-
-    let combined = format!(
-        "// === has_role(operator, AUTHORIZER) ===\n\n{}\n\n// === only_role(operator, AUTHORIZER) ===\n\n{}",
-        has_role_formatted, only_role_formatted
-    );
-
-    insta::assert_snapshot!(combined);
-}
-
-// ============================================
-// AUTHORIZER: table-driven assertion tests
-// ============================================
-
-#[test]
-fn test_authorizer_role_generates_auth_check_instead_of_ensure_role() {
-    struct Case {
-        name: &'static str,
-        args: TokenStream,
-        input: TokenStream,
-        require_auth: bool,
-        expected_ensure_stmt: &'static str,
-        expected_auth_stmt: Option<&'static str>,
-        expected_stmt_count: usize,
-    }
-
-    let cases = vec![
-        Case {
-            name: "has_role with AUTHORIZER: Env ref + Address value",
-            args: quote! { operator, AUTHORIZER },
-            input: quote! { pub fn admin_action(env: &Env, operator: Address) {} },
-            require_auth: false,
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,AUTHORIZER),&operator);",
-            expected_auth_stmt: None,
-            expected_stmt_count: 1,
-        },
-        Case {
-            name: "only_role with AUTHORIZER: Env owned + Address value",
-            args: quote! { operator, AUTHORIZER },
-            input: quote! { pub fn admin_action(env: Env, operator: Address) {} },
-            require_auth: true,
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(&env,&soroban_sdk::Symbol::new(&env,AUTHORIZER),&operator);",
-            expected_auth_stmt: Some("operator.require_auth();"),
-            expected_stmt_count: 2,
-        },
-        Case {
-            name: "only_role with AUTHORIZER: Env ref + &Address",
-            args: quote! { operator, AUTHORIZER },
-            input: quote! { pub fn admin_action(env: &Env, operator: &Address) {} },
-            require_auth: true,
-            expected_ensure_stmt: "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,AUTHORIZER),operator);",
-            expected_auth_stmt: Some("operator.require_auth();"),
-            expected_stmt_count: 2,
-        },
-    ];
-
-    for c in cases {
-        assert_role_check_exact_stmts(
-            c.args,
-            c.input,
-            c.require_auth,
-            c.expected_ensure_stmt,
-            c.expected_auth_stmt,
-            Some(c.expected_stmt_count),
-            c.name,
-        );
-    }
-}
-
-#[test]
-fn test_non_authorizer_role_still_uses_ensure_role() {
-    let args = quote! { caller, MINTER_ROLE };
-    let input = quote! { pub fn mint(env: &Env, caller: Address) {} };
-    assert_role_check_exact_stmts(
-        args,
-        input,
-        false,
-        "utils::rbac::ensure_role::<Self>(env,&soroban_sdk::Symbol::new(env,MINTER_ROLE),&caller);",
-        None,
-        Some(1),
-        "non-AUTHORIZER const still goes through ensure_role",
-    );
-}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__auth__snapshot_generated_multisig_code.snap

@@ -1,31 +0,0 @@
----
-source: contracts/common-macros/src/tests/auth.rs
-expression: combined
----
-// === Unit struct ===
-
-pub struct MyContract;
-use utils::{auth::Auth as _, multisig::MultiSig as _};
-#[common_macros::contract_impl]
-impl utils::auth::Auth for MyContract {
-    fn authorizer(env: &soroban_sdk::Env) -> Option<soroban_sdk::Address> {
-        Some(env.current_contract_address())
-    }
-}
-#[common_macros::contract_impl(contracttrait)]
-impl utils::multisig::MultiSig for MyContract {}
-
-
-// === Tuple struct ===
-
-#[derive(Copy, Clone)]
-pub struct MyContract(pub u32);
-use utils::{auth::Auth as _, multisig::MultiSig as _};
-#[common_macros::contract_impl]
-impl utils::auth::Auth for MyContract {
-    fn authorizer(env: &soroban_sdk::Env) -> Option<soroban_sdk::Address> {
-        Some(env.current_contract_address())
-    }
-}
-#[common_macros::contract_impl(contracttrait)]
-impl utils::multisig::MultiSig for MyContract {}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__auth__snapshot_generated_ownable_code.snap

@@ -1,39 +0,0 @@
----
-source: contracts/common-macros/src/tests/auth.rs
-assertion_line: 36
-expression: combined
----
-// === Unit struct ===
-
-pub struct MyContract;
-use utils::{auth::Auth as _, ownable::{Ownable as _, OwnableInitializer as _}};
-impl utils::ownable::OwnableInitializer for MyContract {}
-#[common_macros::contract_impl]
-impl utils::auth::Auth for MyContract {
-    fn authorizer(env: &soroban_sdk::Env) -> Option<soroban_sdk::Address> {
-        <Self as utils::ownable::Ownable>::owner(env)
-    }
-}
-#[common_macros::contract_impl(contracttrait)]
-impl utils::ownable::Ownable for MyContract {}
-
-
-// === Generics + fields ===
-
-#[derive(Clone, Debug)]
-pub struct MyContract<T>
-where
-    T: Clone,
-{
-    pub value: T,
-}
-use utils::{auth::Auth as _, ownable::{Ownable as _, OwnableInitializer as _}};
-impl utils::ownable::OwnableInitializer for MyContract {}
-#[common_macros::contract_impl]
-impl utils::auth::Auth for MyContract {
-    fn authorizer(env: &soroban_sdk::Env) -> Option<soroban_sdk::Address> {
-        <Self as utils::ownable::Ownable>::owner(env)
-    }
-}
-#[common_macros::contract_impl(contracttrait)]
-impl utils::ownable::Ownable for MyContract {}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__auth__snapshot_only_auth_preserves_function_signature.snap

@@ -1,19 +0,0 @@
----
-source: contracts/common-macros/src/tests/auth.rs
-assertion_line: 67
-expression: combined
----
-// === Borrowed Env (&Env) ===
-
-pub(crate) async fn admin_action<T: Clone>(env: &Env, value: T) -> Result<T, Error> {
-    utils::auth::require_auth::<Self>(env);
-    Ok(value.clone())
-}
-
-
-// === Owned Env (Env) ===
-
-pub(crate) async fn admin_action<T: Clone>(env: Env, value: T) -> Result<T, Error> {
-    utils::auth::require_auth::<Self>(&env);
-    Ok(value.clone())
-}

package/contracts/common-macros/src/tests/snapshots/common_macros__tests__contract_ttl__snapshot_generated_contractimpl_code.snap

@@ -1,77 +0,0 @@
----
-source: contracts/common-macros/src/tests/contract_ttl.rs
-expression: combined
----
-// === Inherent Impl (no attr) ===
-
-#[soroban_sdk::contractimpl]
-impl MyContract {
-    const A_CONST: u32 = 1;
-    type Alias = u32;
-    /// Public method with Env - should have TTL extension
-    pub fn public_with_env(env: Env, value: u32) -> u32 {
-        utils::ttl_configurable::extend_instance_ttl(&env);
-        value * 2
-    }
-    /// Public method with qualified Env path - should have TTL extension
-    pub fn with_qualified_env(env: soroban_sdk::Env) -> u32 {
-        utils::ttl_configurable::extend_instance_ttl(&env);
-        42
-    }
-    /// Public method with Env not as first parameter - should have TTL extension
-    pub fn env_second(value: u32, env: &Env) -> u32 {
-        utils::ttl_configurable::extend_instance_ttl(env);
-        value * 2
-    }
-    /// Public method without Env - should NOT have TTL extension
-    pub fn public_without_env(value: u32) -> u32 {
-        value * 4
-    }
-    /// Private method with Env - should NOT have TTL extension (not public)
-    fn private_with_env(env: Env, value: u32) -> u32 {
-        value * 5
-    }
-    /// Pub(crate) method with Env - should NOT have TTL extension (not fully public)
-    pub(crate) fn pub_crate_with_env(env: Env, value: u32) -> u32 {
-        value * 7
-    }
-    /// Constructor method - should have init_default_ttl_configs
-    pub fn __constructor(env: &Env, value: u32) {
-        utils::ttl_configurable::init_default_ttl_configs(env);
-        let _ = value * 2;
-    }
-}
-
-
-// === Trait Impl (no attr) ===
-
-#[soroban_sdk::contractimpl]
-impl SomeTrait for MyContract {
-    /// Trait method with Env - should have TTL extension
-    fn trait_method_with_env(env: Env, value: u32) -> u32 {
-        utils::ttl_configurable::extend_instance_ttl(&env);
-        value * 2
-    }
-    /// Trait method without Env - should NOT have TTL extension
-    fn trait_method_without_env(value: u32) -> u32 {
-        value * 4
-    }
-    /// Trait method with macro attribute - should have TTL extension
-    #[common_macros::only_auth]
-    fn trait_method_with_only_auth_attribute(env: Env, value: u32) -> u32 {
-        utils::ttl_configurable::extend_instance_ttl(&env);
-        value * 5
-    }
-}
-
-
-// === Trait Impl (contracttrait attr) ===
-
-#[soroban_sdk::contractimpl(contracttrait)]
-impl AnotherTrait for MyContract {
-    /// Trait method with contracttrait attr - should have TTL extension
-    fn contracttrait_method(env: &Env, value: u32) -> u32 {
-        utils::ttl_configurable::extend_instance_ttl(env);
-        value * 3
-    }
-}