@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.10

package/Cargo.lock

@@ -229,6 +229,7 @@ dependencies = [
  "common-macros",
  "endpoint-v2",
  "soroban-sdk",
+ "utils",
 ]
 
 [[package]]
@@ -332,6 +333,7 @@ dependencies = [
  "assert_unordered",
  "common-macros",
  "endpoint-v2",
+ "executor",
  "message-lib-common",
  "oapp",
  "oapp-macros",
@@ -585,6 +587,35 @@ version = "0.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f678cf4a922c215c63e0de95eb1ff08a958a81d47e485cf9da1e27bf6305cfa5"
 
+[[package]]
+name = "dvn"
+version = "0.0.1"
+dependencies = [
+ "cfg-if",
+ "common-macros",
+ "ed25519-dalek",
+ "endpoint-v2",
+ "insta",
+ "k256",
+ "message-lib-common",
+ "rand",
+ "sha3",
+ "soroban-sdk",
+ "utils",
+ "worker",
+]
+
+[[package]]
+name = "dvn-fee-lib"
+version = "0.0.1"
+dependencies = [
+ "cfg-if",
+ "common-macros",
+ "message-lib-common",
+ "soroban-sdk",
+ "worker",
+]
+
 [[package]]
 name = "dyn-clone"
 version = "1.0.20"
@@ -602,6 +633,7 @@ dependencies = [
  "elliptic-curve",
  "rfc6979",
  "signature",
+ "spki",
 ]
 
 [[package]]
@@ -647,6 +679,7 @@ dependencies = [
  "ff",
  "generic-array",
  "group",
+ "pkcs8",
  "rand_core",
  "sec1",
  "subtle",
@@ -692,15 +725,37 @@ checksum = "ca81e6b4777c89fd810c25a4be2b1bd93ea034fbe58e6a75216a34c6b82c539b"
 name = "executor"
 version = "0.0.1"
 dependencies = [
+ "cfg-if",
  "common-macros",
  "endpoint-v2",
  "message-lib-common",
  "soroban-sdk",
- "stellar-access",
- "stellar-contract-utils",
- "stellar-macros",
  "utils",
- "worker-common",
+ "worker",
+]
+
+[[package]]
+name = "executor-fee-lib"
+version = "0.0.1"
+dependencies = [
+ "common-macros",
+ "message-lib-common",
+ "soroban-sdk",
+ "utils",
+ "worker",
+]
+
+[[package]]
+name = "executor-helper"
+version = "0.0.1"
+dependencies = [
+ "cfg-if",
+ "common-macros",
+ "endpoint-v2",
+ "executor",
+ "soroban-sdk",
+ "utils",
+ "worker",
 ]
 
 [[package]]
@@ -968,7 +1023,9 @@ dependencies = [
  "cfg-if",
  "ecdsa",
  "elliptic-curve",
+ "once_cell",
  "sha2 0.10.9",
+ "signature",
 ]
 
 [[package]]
@@ -1090,20 +1147,50 @@ dependencies = [
 [[package]]
 name = "oapp-macros"
 version = "0.0.1"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.108",
+]
+
+[[package]]
+name = "oapps"
+version = "0.0.1"
+
+[[package]]
+name = "oft"
+version = "0.0.1"
 dependencies = [
  "common-macros",
  "endpoint-v2",
+ "insta",
+ "message-lib-common",
  "oapp",
- "proc-macro2",
- "quote",
+ "oapp-macros",
+ "simple-message-lib",
  "soroban-sdk",
- "syn 2.0.108",
+ "stellar-macros",
+ "stellar-tokens",
  "utils",
 ]
 
 [[package]]
-name = "oapps"
+name = "oft-mint-burn"
 version = "0.0.1"
+dependencies = [
+ "assert_unordered",
+ "common-macros",
+ "endpoint-v2",
+ "executor",
+ "message-lib-common",
+ "oapp",
+ "oapp-macros",
+ "oft",
+ "simple-message-lib",
+ "soroban-sdk",
+ "utils",
+]
 
 [[package]]
 name = "once_cell"
@@ -1322,6 +1409,7 @@ dependencies = [
  "base16ct",
  "der",
  "generic-array",
+ "pkcs8",
  "subtle",
  "zeroize",
 ]
@@ -1575,9 +1663,9 @@ dependencies = [
 
 [[package]]
 name = "soroban-ledger-snapshot"
-version = "23.3.0"
+version = "23.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f778688aade32f689dd386878e7ff553ccd31f7de194da52db972a2a667baa8"
+checksum = "c9c4500634698292eabdc97ec7e98b817d8c343ca7ddcf1ae25f985b0f7ee4da"
 dependencies = [
  "serde",
  "serde_json",
@@ -1589,9 +1677,9 @@ dependencies = [
 
 [[package]]
 name = "soroban-sdk"
-version = "23.3.0"
+version = "23.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64ddf4cb462f95404af5f38bacd41f61285ca8af8099b0875ad2cdbb133690e4"
+checksum = "7fdaa5d2d75769a5df6015b476882bdf186414c7558c241911e79d75b39b515d"
 dependencies = [
  "arbitrary",
  "bytes-lit",
@@ -1613,9 +1701,9 @@ dependencies = [
 
 [[package]]
 name = "soroban-sdk-macros"
-version = "23.3.0"
+version = "23.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "632bdcd72882afa0f2490616944d63610e0d40e186aec74170cc5dd21f75df44"
+checksum = "50ed4dc6b43003c278fe8a7a80d94542232eb1b56e311dd71b73f7d646e1e7a4"
 dependencies = [
  "darling 0.20.11",
  "heck 0.5.0",
@@ -1633,9 +1721,9 @@ dependencies = [
 
 [[package]]
 name = "soroban-spec"
-version = "23.3.0"
+version = "23.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83e23eb9e61eb7831a169132982f18cd4664d0b109f72871ef25645cfe6a0a91"
+checksum = "c55623057d24c2a5326f519b56a756463f2aeb7ae62af0978fa0b9bab59d732d"
 dependencies = [
  "base64 0.22.1",
  "stellar-xdr",
@@ -1645,9 +1733,9 @@ dependencies = [
 
 [[package]]
 name = "soroban-spec-rust"
-version = "23.3.0"
+version = "23.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44a20e878c4f6c995541dce4269c52170f2655decc4e794ab70624b936adc1c7"
+checksum = "e9eec1039dfb0dda4c2fb8699a6e5a1c3c5a682432bdaee5fd6a7bb90c45db0c"
 dependencies = [
  "prettyplease",
  "proc-macro2",
@@ -1714,29 +1802,18 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
-[[package]]
-name = "stellar-access"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5345cb2ba75b98f4b355fc95952e418046e9fe46e4fd94648c719993511a29d"
-dependencies = [
- "soroban-sdk",
-]
-
 [[package]]
 name = "stellar-contract-utils"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fc596a92adf2bbfbc6022c5d218c9bace96554de95e350e38e9da4a5a5ea77d"
+version = "0.5.1"
+source = "git+https://github.com/OpenZeppelin/stellar-contracts.git?tag=v0.5.1#372a162a6df8aed108befa5573d30a8ca49cb271"
 dependencies = [
  "soroban-sdk",
 ]
 
 [[package]]
 name = "stellar-macros"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcc533c344e11f77f34f03e7cdc8d70da83784c746953bfd4b2d62f5423130ac"
+version = "0.5.1"
+source = "git+https://github.com/OpenZeppelin/stellar-contracts.git?tag=v0.5.1#372a162a6df8aed108befa5573d30a8ca49cb271"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1763,6 +1840,15 @@ dependencies = [
  "data-encoding",
 ]
 
+[[package]]
+name = "stellar-tokens"
+version = "0.5.1"
+source = "git+https://github.com/OpenZeppelin/stellar-contracts.git?tag=v0.5.1#372a162a6df8aed108befa5573d30a8ca49cb271"
+dependencies = [
+ "soroban-sdk",
+ "stellar-contract-utils",
+]
+
 [[package]]
 name = "stellar-xdr"
 version = "23.0.0"
@@ -2181,14 +2267,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
-name = "worker-common"
+name = "worker"
 version = "0.0.1"
 dependencies = [
  "common-macros",
  "soroban-sdk",
- "stellar-access",
- "stellar-contract-utils",
- "stellar-macros",
  "utils",
 ]
 

package/Cargo.toml

@@ -14,7 +14,7 @@ license = "MIT"
 version = "0.0.1"
 
 [workspace.dependencies]
-soroban-sdk = {version = "23.3.0", features = ["hazmat-address"]}
+soroban-sdk = {version = "23.4.0", features = ["hazmat-address", "hazmat-crypto"]}
 cfg-if = { version = "1.0", default-features = false }
 hex-literal = "1.0.0"
 endpoint-v2 = { path = "contracts/endpoint-v2", default-features = false }
@@ -25,11 +25,14 @@ message-lib-common = { path = "contracts/message-libs/message-lib-common" }
 oapp = { path = "contracts/oapps/oapp" }
 simple-message-lib = { path = "contracts/message-libs/simple-message-lib" }
 treasury = { path = "contracts/message-libs/treasury" }
-worker-common = { path = "contracts/workers/worker-common" }
+worker = { path = "contracts/workers/worker" }
 executor = { path = "contracts/workers/executor" }
-stellar-access = "0.5.0"
-stellar-macros = "0.5.0"
-stellar-contract-utils = "0.5.0"
+executor-helper = { path = "contracts/workers/executor-helper" }
+executor-fee-lib = { path = "contracts/workers/executor-fee-lib" }
+oft = { path = "contracts/oapps/oft" }
+stellar-macros = { git = "https://github.com/OpenZeppelin/stellar-contracts.git", tag = "v0.5.1" }
+stellar-tokens = { git = "https://github.com/OpenZeppelin/stellar-contracts.git", tag = "v0.5.1" }
+stellar-contract-utils = { git = "https://github.com/OpenZeppelin/stellar-contracts.git", tag = "v0.5.1" }
 insta = "1.44.3"
 
 # Fast dev builds for testing

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

@@ -0,0 +1,44 @@
+use crate::utils;
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{parse_quote, ImplItem, ItemImpl, Visibility};
+
+/// Generates a `#[soroban_sdk::contractimpl]` with automatic instance TTL extension.
+pub fn contract_impl(attr: TokenStream, input: TokenStream) -> TokenStream {
+    let mut impl_block: ItemImpl = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse impl block: {}", e));
+
+    let is_trait_impl = impl_block.trait_.is_some();
+
+    for item in &mut impl_block.items {
+        let ImplItem::Fn(method) = item else { continue };
+
+        // For trait impls, process all methods; for inherent impls, only public methods
+        if !is_trait_impl && !matches!(method.vis, Visibility::Public(_)) {
+            continue;
+        }
+
+        // Skip methods without Env parameter
+        let Some(env_ident) = utils::find_env_ident(&method.sig.inputs) else { continue };
+
+        // TODO: should support Env instead of &Env?
+        // Use fully qualified syntax to call ttl_configs from TtlConfigurable trait
+        let extend_ttl_stmt = parse_quote! {
+            if let Some(instance_ttl) = utils::ttl::TtlConfigStorage::instance(#env_ident) {
+                #env_ident.storage().instance().extend_ttl(instance_ttl.threshold, instance_ttl.extend_to);
+            }
+        };
+        method.block.stmts.insert(0, extend_ttl_stmt);
+    }
+
+    if attr.is_empty() {
+        quote! {
+            #[soroban_sdk::contractimpl]
+            #impl_block
+        }
+    } else {
+        quote! {
+            #[soroban_sdk::contractimpl(#attr)]
+            #impl_block
+        }
+    }
+}

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

@@ -15,14 +15,14 @@
 //!
 //!
 use proc_macro::TokenStream;
-use quote::quote;
-use syn::{parse_macro_input, ItemFn, ItemStruct};
 
+mod contract_impl;
 mod error;
 mod event;
 mod ownable;
 mod storage;
 mod ttl_configurable;
+mod utils;
 
 #[cfg(test)]
 mod tests;
@@ -33,47 +33,54 @@ mod tests;
 
 /// Generates strongly-typed storage API from enum variants.
 ///
-/// Transforms a storage enum into getter/setter/remove/set_or_remove/has/extend_ttl methods with TTL support.
+/// Transforms a storage enum into getter/setter/remove/set_or_remove/has/extend_ttl methods.
+/// TTL extension is automatic for persistent storage by default.
 ///
 /// # Example
 /// ```ignore
-/// #[storage(MyTtlProvider)]
+/// #[storage]
 /// pub enum DataKey {
 ///     #[instance(u32)]
 ///     Counter,
 ///
 ///     #[persistent(Address)]
-///     #[default(0)]
+///     #[default(Address::default())]
+///     Owner,
+///
+///     #[persistent(u64)]
 ///     Nonce { user: Address },
 ///
+///     #[persistent(BytesN<32>)]
+///     #[no_ttl_extension]  // opt-out of automatic TTL extension
+///     CacheData,
+///
 ///     #[temporary(BytesN<32>)]
-///     #[no_auto_ttl_extension]
 ///     TempData,
 /// }
 ///
-/// // Generated API:
-/// DataKey::counter(&env)                          // -> Option<u32>
-/// DataKey::set_counter(&env, &value)              // set value
-/// DataKey::has_counter(&env)                      // -> bool
-/// DataKey::remove_counter(&env)                   // remove entry
-/// DataKey::set_or_remove_counter(&env, &opt)      // set if Some, remove if None
-/// DataKey::extend_ttl_counter(&env, threshold, extend_to)  // manual TTL extension
+/// // Generated API for each variant:
+/// DataKey::counter(&env)                               // -> Option<u32>
+/// DataKey::set_counter(&env, &value)                   // set value
+/// DataKey::has_counter(&env)                           // -> bool
+/// DataKey::remove_counter(&env)                        // remove entry
+/// DataKey::set_or_remove_counter(&env, &opt)           // set if Some, remove if None
+/// DataKey::extend_counter_ttl(&env, threshold, extend_to)  // manual TTL extension
 ///
 /// // With fields (keyed storage):
-/// DataKey::nonce(&env, user)                      // -> u64 (has default)
-/// DataKey::set_nonce(&env, user, &value)
-/// DataKey::set_or_remove_nonce(&env, user, &opt)  // conditionally set or remove
+/// DataKey::nonce(&env, &user)                          // -> Option<u64>
+/// DataKey::set_nonce(&env, &user, &value)
+/// DataKey::set_or_remove_nonce(&env, &user, &opt)
 /// ```
 ///
 /// # Storage Types (required, exactly one per variant)
 /// - `#[instance(Type)]` - Stored with contract instance
-/// - `#[persistent(Type)]` - Durable ledger entries
+/// - `#[persistent(Type)]` - Durable ledger entries (TTL extended automatically)
 /// - `#[temporary(Type)]` - Short-lived entries
 ///
 /// # Variant Attributes (optional)
 /// - `#[default(expr)]` - Default value; changes getter return from `Option<T>` to `T`
-/// - `#[no_auto_ttl_extension]` - Disables automatic TTL extension on access
 /// - `#[name("custom")]` - Override the generated function name base
+/// - `#[no_ttl_extension]` - Disable automatic TTL extension for this persistent variant
 #[proc_macro_attribute]
 pub fn storage(attr: TokenStream, item: TokenStream) -> TokenStream {
     storage::generate_storage(attr.into(), item.into()).into()
@@ -161,20 +168,11 @@ pub fn contract_error(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 ///
 /// Generated code includes:
-/// - `__init_owner(env, owner)` - Internal method to initialize owner
-/// - `owner(env)` - Get current owner
-/// - `transfer_ownership(env, new_owner)` - Transfer ownership
+/// - `OwnableInitializer` trait impl - Use `<Self as OwnableInitializer>::init_owner(env, owner)` to initialize
+/// - `Ownable` trait impl - `owner(env)`, `transfer_ownership(env, new_owner)`, `renounce_ownership(env)`
 #[proc_macro_attribute]
 pub fn ownable(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(item as ItemStruct);
-
-    // Generate the ownable implementation
-    let ownable_impl = ownable::generate_ownable_impl(&input.ident);
-
-    TokenStream::from(quote! {
-        #input
-        #ownable_impl
-    })
+    ownable::generate_ownable_impl(item.into()).into()
 }
 
 // ============================================================================
@@ -213,8 +211,7 @@ pub fn ownable(_attr: TokenStream, item: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_attribute]
 pub fn only_owner(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let input_fn = parse_macro_input!(item as ItemFn);
-    ownable::prepend_only_owner_check(input_fn).into()
+    ownable::prepend_only_owner_check(item.into()).into()
 }
 
 // ============================================================================
@@ -232,24 +229,73 @@ pub fn only_owner(_attr: TokenStream, item: TokenStream) -> TokenStream {
 /// #[ttl_configurable]
 /// pub struct MyContract;
 ///
-/// #[contractimpl]
+/// #[contract_impl]
 /// impl MyContract {
 ///     pub fn __constructor(env: &Env, owner: &Address) {
-///         Self::__init_owner(env, owner);
+///         <Self as utils::ownable::OwnableInitializer>::init_owner(env, owner);
 ///     }
 /// }
 /// ```
 ///
 /// Generated code includes:
 /// - `#[ownable]` attribute on the struct (provides owner management)
-/// - `set_ttl_config(env, instance, persistent, temporary)` - Set TTL config (owner only)
-/// - `ttl_config(env)` - Get current TTL configuration (instance, persistent, temporary)
-/// - `freeze_ttl_config(env)` - Permanently freeze TTL config (owner only)
-/// - `is_ttl_config_frozen(env)` - Check if TTL config is frozen
+/// - `set_ttl_configs(env, instance, persistent)` - Set TTL configs (owner only)
+/// - `ttl_configs(env)` - Get current TTL configs (instance, persistent)
+/// - `freeze_ttl_configs(env)` - Permanently freeze TTL configs (owner only)
+/// - `is_ttl_configs_frozen(env)` - Check if TTL configs are frozen
 ///
 /// See [`ownable`] for the owner management methods also generated.
 #[proc_macro_attribute]
 pub fn ttl_configurable(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(item as ItemStruct);
-    ttl_configurable::generate_ttl_configurable_impl(&input).into()
+    ttl_configurable::generate_ttl_configurable_impl(item.into()).into()
+}
+
+// ============================================================================
+// Contract Impl Macro
+// ============================================================================
+
+/// Wraps `#[soroban_sdk::contractimpl]` with automatic instance TTL extension.
+///
+/// This macro applies `#[soroban_sdk::contractimpl]` and injects TTL extension logic
+/// at the beginning of each contract entry function to keep the contract instance alive.
+///
+/// # Requirements
+/// - The contract struct must have `#[ttl_configurable]` applied to provide `ttl_config()`
+/// - Methods must have an `Env` parameter to receive TTL extension
+///
+/// # Behavior
+/// - **Inherent impls** (`impl MyContract`): Only public methods receive TTL extension
+/// - **Trait impls** (`impl SomeTrait for MyContract`): All methods receive TTL extension
+/// - Methods without an `Env` parameter are skipped
+///
+/// # Example
+/// ```ignore
+/// #[contract]
+/// #[ttl_configurable]
+/// pub struct MyContract;
+///
+/// #[contract_impl]
+/// impl MyContract {
+///     pub fn my_method(env: &Env) {
+///         // TTL extension is automatically injected here
+///         // ... your code
+///     }
+/// }
+/// ```
+///
+/// Generated code (conceptual):
+/// ```ignore
+/// #[soroban_sdk::contractimpl]
+/// impl MyContract {
+///     pub fn my_method(env: &Env) {
+///         if let Some(ttl) = <Self as ::utils::ttl::TtlConfigurable>::ttl_config(env).0 {
+///             env.storage().instance().extend_ttl(ttl.threshold, ttl.extend_to);
+///         }
+///         // ... your code
+///     }
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn contract_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
+    contract_impl::contract_impl(attr.into(), item.into()).into()
 }

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

@@ -1,15 +1,21 @@
-use proc_macro2::{Ident, TokenStream};
+use crate::utils::expect_env_ident;
+use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
-use syn::{parse_quote, FnArg, ItemFn, Pat, Type, TypePath};
+use syn::{parse_quote, ItemFn, ItemStruct};
 
-pub fn generate_ownable_impl(name: &Ident) -> TokenStream {
-    quote! {
+/// Generates the ownable implementation from the `#[ownable]` attribute macro.
+pub fn generate_ownable_impl(input: TokenStream) -> TokenStream {
+    let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
+    let name = &item_struct.ident;
+
+    let ownable_impl = quote! {
         use utils::ownable::Ownable as _;
+        use utils::ownable::OwnableInitializer as _;
 
-        impl #name {
-            /// Initialize the contract owner. Should be called during contract initialization.
-            pub(crate) fn __init_owner(env: &soroban_sdk::Env, owner: &soroban_sdk::Address) {
-                utils::ownable::DefaultOwnable::init_owner(env, owner);
+        /// Implement the OwnableInitializer trait for the contract.
+        impl utils::ownable::OwnableInitializer for #name {
+            fn init_owner(env: &soroban_sdk::Env, owner: &soroban_sdk::Address) {
+                <utils::ownable::DefaultOwnable as utils::ownable::OwnableInitializer>::init_owner(env, owner)
             }
         }
 
@@ -28,36 +34,22 @@ pub fn generate_ownable_impl(name: &Ident) -> TokenStream {
                 utils::ownable::DefaultOwnable::renounce_ownership(env)
             }
         }
+    };
+
+    quote! {
+        #item_struct
+        #ownable_impl
     }
 }
 
 /// Prepends an owner authentication check to a method.
-pub fn prepend_only_owner_check(mut input_fn: ItemFn) -> TokenStream {
-    // Find the Env argument in the function signature
-    let env_ident = input_fn
-        .sig
-        .inputs
-        .iter()
-        .find_map(|arg| {
-            let FnArg::Typed(pat_type) = arg else { return None };
-            if !is_env_type(&pat_type.ty) {
-                return None;
-            }
-            let Pat::Ident(pat) = pat_type.pat.as_ref() else { return None };
-            Some(&pat.ident)
-        })
-        .expect("function must have an Env argument");
+pub fn prepend_only_owner_check(input: TokenStream) -> TokenStream {
+    let mut input_fn: ItemFn = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse function: {}", e));
 
+    let env_ident = expect_env_ident(&input_fn.sig.inputs);
+
+    // TODO: should support Env instead of &Env?
     // Insert the owner authentication check at the beginning of the function body
     input_fn.block.stmts.insert(0, parse_quote!(utils::ownable::require_owner_auth::<Self>(#env_ident);));
     input_fn.into_token_stream()
 }
-
-/// Checks if a type is an `Env` type.
-fn is_env_type(ty: &Type) -> bool {
-    match ty {
-        Type::Path(TypePath { path, .. }) => path.segments.last().is_some_and(|seg| seg.ident == "Env"),
-        Type::Reference(r) => is_env_type(&r.elem),
-        _ => false,
-    }
-}