feat(axelar-std-derive): add contractstorage attribute macro

contracts/stellar-example/src/storage_types.rs

@@ -4,7 +4,7 @@ use stellar_interchain_token_service::types::TokenManagerType;
 
 #[contractstorage]
 #[derive(Clone, Debug)]
-pub enum DataKey {
+enum DataKey {
     #[instance]
     #[value(Address)]
     Gateway,
@@ -28,7 +28,7 @@ pub enum DataKey {
 
 #[contracttype]
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub struct TokenIdConfig {
+struct TokenIdConfig {
     pub token_address: Address,
     pub token_manager_type: TokenManagerType,
 }

packages/stellar-axelar-std-derive/src/lib.rs

@@ -2,12 +2,12 @@
 //!
 //! This ensures compatibility and prevents cyclic dependency issues during testing and release.
 
-mod contractstorage;
 mod into_event;
 mod its_executable;
 mod operatable;
 mod ownable;
 mod pausable;
+mod storage;
 mod upgradable;
 
 use proc_macro::TokenStream;
@@ -249,7 +249,7 @@ pub fn derive_its_executable(input: TokenStream) -> TokenStream {
 ///
 /// #[contractstorage]
 /// #[derive(Clone, Debug)]
-/// pub enum DataKey {
+/// enum DataKey {
 ///     #[instance]
 ///     #[value(Address)]
 ///     Owner,
@@ -287,5 +287,5 @@ pub fn derive_its_executable(input: TokenStream) -> TokenStream {
 #[proc_macro_attribute]
 pub fn contractstorage(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let input = parse_macro_input!(item as DeriveInput);
-    contractstorage::contractstorage(&input).into()
+    storage::contractstorage(&input).into()
 }

packages/stellar-axelar-std-derive/src/contractstorage.rs → packages/stellar-axelar-std-derive/src/storage.rs

@@ -134,8 +134,7 @@ fn storage_fns(
             extend_persistent_ttl(env, &key);
         },
         StorageType::Instance => quote! {
-            use stellar_axelar_std::ttl::extend_instance_ttl;
-            extend_instance_ttl(env);
+            stellar_axelar_std::ttl::extend_instance_ttl(env);
         },
         _ => quote! {},
     };

packages/stellar-axelar-std/src/tests/storage.rs

@@ -7,58 +7,62 @@ use crate::contractstorage;
 #[contract]
 pub struct Contract;
 
-#[contractstorage]
-pub enum DataKey {
-    #[instance]
-    #[value(u32)]
-    Counter,
-
-    #[persistent]
-    #[value(String)]
-    Message { sender: Address },
-
-    #[temporary]
-    #[value(Address)]
-    LastCaller { timestamp: u64 },
-
-    #[persistent]
-    #[value(bool)]
-    Flag { key: String, owner: Address },
+mod storage {
+    use super::*;
+
+    #[contractstorage]
+    enum DataKey {
+        #[instance]
+        #[value(u32)]
+        Counter,
+
+        #[persistent]
+        #[value(String)]
+        Message { sender: Address },
+
+        #[temporary]
+        #[value(Address)]
+        LastCaller { timestamp: u64 },
+
+        #[persistent]
+        #[value(bool)]
+        Flag { key: String, owner: Address },
+    }
 }
 
 #[contractimpl]
 impl Contract {
     pub const fn __constructor() {}
 
     pub fn increment_counter(env: &Env) -> u32 {
-        let current_counter = DataKey::get_counter(env).unwrap_or(0);
+        let current_counter = storage::DataKey::get_counter(env).unwrap_or(0);
         let new_counter = current_counter + 1;
-        DataKey::set_counter(env, &new_counter);
+        storage::DataKey::set_counter(env, &new_counter);
         new_counter
     }
 
     pub fn set_message(env: &Env, sender: Address, message: String) {
-        DataKey::set_message(env, sender, &message);
+        storage::DataKey::set_message(env, sender, &message);
     }
 
     pub fn message(env: &Env, sender: Address) -> Option<String> {
-        DataKey::get_message(env, sender)
+        storage::DataKey::get_message(env, sender)
     }
 
     pub fn set_last_caller(env: &Env, timestamp: u64, caller: Address) {
-        DataKey::set_last_caller(env, timestamp, &caller);
+        storage::DataKey::set_last_caller(env, timestamp, &caller);
     }
 
     pub fn last_caller(env: &Env, timestamp: u64) -> Option<Address> {
-        DataKey::get_last_caller(env, timestamp)
+        storage::DataKey::get_last_caller(env, timestamp)
     }
 
     pub fn set_flag(env: &Env, key: String, owner: Address, value: bool) {
-        DataKey::set_flag(env, key, owner, &value);
+        storage::DataKey::set_flag(env, key, owner, &value);
     }
 
     pub fn flag(env: &Env, key: String, owner: Address) -> Option<bool> {
-        DataKey::get_flag(env, key, owner)
+        storage::DataKey::get_flag(env, key, owner)
     }
 }