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

contracts/stellar-example/src/contract.rs

@@ -12,7 +12,7 @@ use stellar_interchain_token_service::InterchainTokenServiceClient;
 
 use crate::event::{ExecutedEvent, TokenReceivedEvent, TokenSentEvent};
 use crate::interface::ExampleInterface;
-use crate::storage_types::DataKey;
+use crate::storage;
 
 #[contract]
 #[derive(InterchainTokenExecutable)]
@@ -34,10 +34,7 @@ impl AxelarExecutableInterface for Example {
     type Error = ExampleError;
 
     fn gateway(env: &Env) -> Address {
-        env.storage()
-            .instance()
-            .get(&DataKey::Gateway)
-            .expect("gateway not found")
+        storage::gateway(env).expect("gateway not found")
     }
 
     fn execute(
@@ -65,10 +62,7 @@ impl CustomInterchainTokenExecutable for Example {
     type Error = ExampleError;
 
     fn __interchain_token_service(env: &Env) -> Address {
-        env.storage()
-            .instance()
-            .get(&DataKey::InterchainTokenService)
-            .expect("ITS not found")
+        storage::interchain_token_service(env).expect("interchain token service not found")
     }
 
     fn __authorized_execute_with_token(
@@ -115,23 +109,16 @@ impl Example {
         gas_service: Address,
         interchain_token_service: Address,
     ) {
-        env.storage().instance().set(&DataKey::Gateway, &gateway);
-        env.storage()
-            .instance()
-            .set(&DataKey::GasService, &gas_service);
-        env.storage()
-            .instance()
-            .set(&DataKey::InterchainTokenService, &interchain_token_service);
+        storage::set_gateway(env, &gateway);
+        storage::set_gas_service(env, &gas_service);
+        storage::set_interchain_token_service(env, &interchain_token_service);
     }
 }
 
 #[contractimpl]
 impl ExampleInterface for Example {
     fn gas_service(env: &Env) -> Address {
-        env.storage()
-            .instance()
-            .get(&DataKey::GasService)
-            .expect("gas service not found")
+        storage::gas_service(env).expect("gas service not found")
     }
 
     fn send(

contracts/stellar-example/src/lib.rs

@@ -6,7 +6,7 @@ extern crate std;
 mod contract;
 pub mod event;
 pub mod interface;
-mod storage_types;
+mod storage;
 
 pub use contract::{Example, ExampleClient};
 

contracts/stellar-example/src/storage.rs

@@ -0,0 +1,18 @@
+use soroban_sdk::{contracttype, Address};
+use stellar_axelar_std::contractstorage;
+
+#[contractstorage]
+#[derive(Clone, Debug)]
+enum DataKey {
+    #[instance]
+    #[value(Address)]
+    Gateway,
+
+    #[instance]
+    #[value(Address)]
+    GasService,
+
+    #[instance]
+    #[value(Address)]
+    InterchainTokenService,
+}

packages/stellar-axelar-std-derive/Cargo.toml

@@ -12,10 +12,13 @@ proc-macro = true
 [features]
 
 [dependencies]
+goldie = { workspace = true }
 heck = "0.5"
+itertools = "0.14"
+prettyplease = "0.2"
 proc-macro2 = { workspace = true }
-quote = "1.0"
-syn = { version = "2.0", features = ["full"] }
+quote = { version = "1.0", default-features = false }
+syn = { version = "2.0", features = ["full", "extra-traits"] }
 
 [dev-dependencies]
 

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

@@ -7,6 +7,7 @@ mod its_executable;
 mod operatable;
 mod ownable;
 mod pausable;
+mod storage;
 mod upgradable;
 
 use proc_macro::TokenStream;
@@ -233,3 +234,58 @@ pub fn derive_its_executable(input: TokenStream) -> TokenStream {
 
     its_executable::its_executable(name).into()
 }
+
+/// Implements a storage interface for a Stellar contract storage enum.
+///
+/// The enum variants define contract data keys, with optional named fields as contract data map keys.
+/// Each variant requires a `#[value(Type)]` attribute to specify the stored value type.
+/// Storage type can be specified with `#[instance]`, `#[persistent]`, or `#[temporary]` attributes (defaults to instance).
+///
+/// # Example
+/// ```rust,ignore
+/// # mod test {
+/// use soroban_sdk::{contract, contractimpl, contractype, Address, Env, String};
+/// use stellar_axelar_std::contractstorage;
+///
+/// #[contractstorage]
+/// #[derive(Clone, Debug)]
+/// enum DataKey {
+///     #[instance]
+///     #[value(Address)]
+///     Owner,
+///
+///     #[persistent]
+///     #[value(String)]
+///     TokenName { token_id: u32 },
+///
+///     #[temporary]
+///     #[value(u64)]
+///     LastUpdate { account: Address },
+/// }
+///
+/// #[contract]
+/// pub struct Contract;
+///
+/// #[contractimpl]
+/// impl Contract {
+///     pub fn __constructor(
+///         env: &Env,
+///         token_id: u32,
+///         name: String,
+///     ) {
+///         // Generates: DataKey::set_token_name(env, token_id, &name);
+///         DataKey::set_token_name(env, token_id, &name);
+///     }
+///
+///     pub fn token_name(env: &Env, token_id: u32) -> Option<String> {
+///         // Generates: DataKey::get_token_name(env, token_id)
+///         DataKey::get_token_name(env, token_id)
+///     }
+/// }
+/// # }
+/// ```
+#[proc_macro_attribute]
+pub fn contractstorage(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as DeriveInput);
+    storage::contractstorage(&input).into()
+}