refactor(registry-tansu-manager): use soroban-sdk-tools typed storage

Replace the hand-rolled `DataKey` enum + raw `env.storage().instance()`
calls with `#[contractstorage(auto_shorten = true)]` from
`soroban-sdk-tools`. The macro generates static one-liner accessors
(`Storage::get_tansu`, `Storage::set_executed`, `Storage::has_executed`,
…) keyed by auto-shortened symbols, eliminating the `DataKey` enum and
the persistent/instance bucket plumbing in `execute`. Behavior, ABI, and
tests are unchanged.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: willemneal

contracts/registry-tansu-manager/src/lib.rs

@@ -4,6 +4,7 @@ use soroban_sdk::{
     contract, contractimpl, contracttype, vec, Address, Bytes, BytesN, Env, IntoVal, String,
     Symbol, Val, Vec,
 };
+use soroban_sdk_tools::{contractstorage, InstanceItem, PersistentMap};
 
 #[soroban_sdk_tools::scerr]
 pub enum Error {
@@ -97,12 +98,16 @@ pub struct Proposal {
     pub outcome_contracts: Option<Vec<OutcomeContract>>,
 }
 
-#[contracttype]
-pub enum DataKey {
-    Tansu,
-    ProjectKey,
-    Registry,
-    Executed(u32),
+#[contractstorage(auto_shorten = true)]
+pub struct Storage {
+    /// Tansu DAO contract this manager queries proposals from.
+    tansu: InstanceItem<Address>,
+    /// Tansu workspace key this manager represents.
+    project_key: InstanceItem<Bytes>,
+    /// Registry contract this manager forwards approved outcomes to.
+    registry: InstanceItem<Address>,
+    /// Proposal IDs that have already been executed (replay guard).
+    executed: PersistentMap<u32, bool>,
 }
 
 #[contract]
@@ -111,22 +116,21 @@ pub struct RegistryTansuManager;
 #[contractimpl]
 impl RegistryTansuManager {
     pub fn __constructor(env: Env, tansu: Address, project_key: Bytes, registry: Address) {
-        let s = env.storage().instance();
-        s.set(&DataKey::Tansu, &tansu);
-        s.set(&DataKey::ProjectKey, &project_key);
-        s.set(&DataKey::Registry, &registry);
+        Storage::set_tansu(&env, &tansu);
+        Storage::set_project_key(&env, &project_key);
+        Storage::set_registry(&env, &registry);
     }
 
     pub fn tansu(env: Env) -> Address {
-        env.storage().instance().get(&DataKey::Tansu).unwrap()
+        Storage::get_tansu(&env).unwrap()
     }
 
     pub fn project_key(env: Env) -> Bytes {
-        env.storage().instance().get(&DataKey::ProjectKey).unwrap()
+        Storage::get_project_key(&env).unwrap()
     }
 
     pub fn registry(env: Env) -> Address {
-        env.storage().instance().get(&DataKey::Registry).unwrap()
+        Storage::get_registry(&env).unwrap()
     }
 
     /// Execute a passed Tansu proposal by forwarding its outcome to the registry.
@@ -138,23 +142,21 @@ impl RegistryTansuManager {
     /// contract is the direct caller (Soroban contract-auth chains for
     /// outgoing invocations; no `authorize_as_current_contract` is needed).
     ///
-    /// Replay-protected: a successful `execute` records `DataKey::Executed(id)`
-    /// permanently; later calls with the same `proposal_id` return
+    /// Replay-protected: a successful `execute` marks the proposal as
+    /// executed; later calls with the same `proposal_id` return
     /// `AlreadyExecuted`.
     ///
     /// Trust: we look up the proposal in Tansu using the stored `project_key`,
     /// so a wrong-project proposal cannot resolve. We do not re-verify
     /// `project_key` against any field of the returned proposal — Tansu's
     /// storage layout makes that lookup the only path.
     pub fn execute(env: Env, proposal_id: u32) -> Result<Val, Error> {
-        let s = env.storage().persistent();
-        if s.has(&DataKey::Executed(proposal_id)) {
+        if Storage::has_executed(&env, &proposal_id) {
             return Err(Error::AlreadyExecuted);
         }
-        let inst = env.storage().instance();
-        let tansu: Address = inst.get(&DataKey::Tansu).unwrap();
-        let project_key: Bytes = inst.get(&DataKey::ProjectKey).unwrap();
-        let registry: Address = inst.get(&DataKey::Registry).unwrap();
+        let tansu = Storage::get_tansu(&env).unwrap();
+        let project_key = Storage::get_project_key(&env).unwrap();
+        let registry = Storage::get_registry(&env).unwrap();
 
         let proposal: Proposal = env.invoke_contract(
             &tansu,
@@ -177,7 +179,7 @@ impl RegistryTansuManager {
         }
 
         let result: Val = env.invoke_contract(&registry, &oc.execute_fn, oc.args);
-        s.set(&DataKey::Executed(proposal_id), &true);
+        Storage::set_executed(&env, &proposal_id, &true);
         Ok(result)
     }
 }

contracts/registry-tansu-manager/src/test.rs

@@ -102,9 +102,7 @@ fn setup() -> Setup {
 
     // Patch the manager's stored registry to the real RegistryStub address.
     env.as_contract(&manager, || {
-        env.storage()
-            .instance()
-            .set(&crate::DataKey::Registry, &registry);
+        crate::Storage::set_registry(&env, &registry);
     });
 
     let manager_client = RegistryTansuManagerClient::new(&env, &manager);