feat: fix wasm registry

Author: willemneal

.gitignore

@@ -1,4 +1,4 @@
 target/
 .soroban/
 .env
-test_snapshots/
+# test_snapshots/

contracts/registry/src/lib.rs

@@ -1,8 +1,10 @@
 #![no_std]
 use loam_sdk::soroban_sdk;
 use loam_subcontract_core::{admin::Admin, Core};
+
+use metadata::PublishedWasm;
 use registry::{
-    contract::Contract as Contract_, wasm::Wasm, Claimable, Deployable, DevDeployable, Publishable,
+    contract::Contract as Contract_, Claimable, Deployable, DevDeployable, Publishable
 };
 
 pub mod error;
@@ -16,7 +18,7 @@ use version::Version;
 
 #[loam_sdk::derive_contract(
     Core(Admin),
-    Publishable(Wasm),
+    Publishable(PublishedWasm),
     Deployable(Contract_),
     Claimable(Contract_),
     DevDeployable(Contract_)

contracts/registry/src/metadata/contract.rs

@@ -1,61 +1,68 @@
-use loam_sdk::soroban_sdk::{self, contracttype, env, to_string, Address, Map, String};
+use loam_sdk::{
+    loamstorage,
+    soroban_sdk::{self, env, Address, LoamKey, PersistentMap, String},
+};
 
-#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd)]
-#[contracttype]
-pub struct ContractMetadata {
-    pub repo: String,
-}
-
-impl Default for ContractMetadata {
-    fn default() -> Self {
-        Self {
-            repo: to_string(""),
-        }
-    }
-}
 //
 
 use crate::{error::Error, version::Version};
 
-use super::PublishedWasm;
+use super::Wasm;
 /// Contains
-#[contracttype]
-#[derive(Clone)]
-pub struct PublishedContract {
-    pub versions: Map<Version, PublishedWasm>,
-    pub author: Address,
+#[loamstorage]
+pub struct PublishedWasm {
+    pub versions: PersistentMap<(String, Version), Wasm>,
+    pub author: PersistentMap<String, Address>,
+    pub most_recent_version: PersistentMap<String, Version>,
 }
 
-impl PublishedContract {
-    pub fn new(author: Address) -> Self {
-        Self {
-            author,
-            versions: Map::new(env()),
-        }
+impl PublishedWasm {
+    pub fn new(name: &String, author: Address) -> Self {
+        env().deployer().with_stellar_asset(serialized_asset)
+        let mut s = Self::default();
+        s.author.set(name.clone(), &author);
+        s
     }
 }
 
-impl PublishedContract {
-    pub fn most_recent_version(&self) -> Result<Version, Error> {
-        self.versions.keys().last().ok_or(Error::NoSuchVersion)
+impl PublishedWasm {
+    pub fn most_recent_version(&self, name: &String) -> Result<Version, Error> {
+        self.most_recent_version
+            .get(name.clone())
+            .ok_or(Error::NoSuchVersion)
     }
 
-    pub fn get(&self, version: Option<Version>) -> Result<PublishedWasm, Error> {
+    pub fn set_most_recent_version(&mut self, name: &String, version: Version) {
+        self.most_recent_version.set(name.clone(), &version);
+    }
+
+    pub fn get(&self, name: &String, version: Option<Version>) -> Result<Wasm, Error> {
         let version = if let Some(version) = version {
             version
         } else {
-            self.most_recent_version()?
+            self.most_recent_version(name)?
         };
-        self.versions.get(version).ok_or(Error::NoSuchVersion)
+        self.versions
+            .get((name.clone(), version))
+            .ok_or(Error::NoSuchVersion)
     }
 
-    pub fn set(&mut self, version: Option<Version>, binary: PublishedWasm) -> Result<(), Error> {
+    pub fn set(
+        &mut self,
+        name: String,
+        version: Option<Version>,
+        binary: Wasm,
+    ) -> Result<(), Error> {
         let version = if let Some(version) = version {
             version
         } else {
-            self.most_recent_version()?
+            self.most_recent_version(&name)?
         };
-        self.versions.set(version, binary);
+        self.versions.set((name, version), &binary);
         Ok(())
     }
+
+    pub fn author(&self, name: &String) -> Option<Address> {
+        self.author.get(name.clone())
+    }
 }

contracts/registry/src/metadata/wasm.rs

@@ -1,11 +1,25 @@
-use loam_sdk::soroban_sdk::{self, contracttype, BytesN};
+use loam_sdk::soroban_sdk::{self, contracttype, to_string, BytesN, String};
 
-use super::ContractMetadata;
+
+
+#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd)]
+#[contracttype]
+pub struct Metadata {
+    pub repo: String,
+}
+
+impl Default for Metadata {
+    fn default() -> Self {
+        Self {
+            repo: to_string(""),
+        }
+    }
+}
 
 /// Contains info about specific version of published binary
 #[contracttype]
 #[derive(Clone, Debug)]
-pub struct PublishedWasm {
+pub struct Wasm {
     pub hash: BytesN<32>,
-    pub metadata: ContractMetadata,
+    pub metadata: Metadata,
 }

contracts/registry/src/registry.rs

@@ -27,7 +27,7 @@ pub trait IsPublishable {
         &self,
         contract_name: soroban_sdk::String,
         version: Option<Version>,
-    ) -> Result<crate::metadata::PublishedWasm, Error>;
+    ) -> Result<crate::metadata::Wasm, Error>;
 
     /// Publish a binary. If contract had been previously published only previous author can publish again
     fn publish(

contracts/registry/src/registry/contract.rs

@@ -2,14 +2,14 @@
 use loam_sdk::{
     loamstorage,
     soroban_sdk::{
-        self, contracttype, env, symbol_short, Address, BytesN, Env, IntoVal, Lazy, LoamKey,
+        self, contracttype, env, symbol_short, Address, BytesN, Env, IntoVal, LoamKey,
         PersistentMap, String, Symbol, Val,
     },
 };
 
 use crate::{
-    error::Error, registry::Publishable, util::hash_string, version::Version,
-    Contract as Contract_, Wasm,
+    error::Error, metadata::PublishedWasm, registry::Publishable, util::hash_string,
+    version::Version, Contract as Contract_,
 };
 
 use super::{IsClaimable, IsDeployable, IsDevDeployable};
@@ -87,10 +87,7 @@ impl IsDeployable for Contract {
         // Publish a deploy event
         let version = version.map_or_else(
             || {
-                let published_contract = Wasm::get_lazy()
-                    .unwrap()
-                    .find_contract(contract_name.clone())?;
-                published_contract.most_recent_version()
+                PublishedWasm::default().most_recent_version(&contract_name)
             },
             Ok,
         )?;

contracts/registry/src/registry/wasm.rs

@@ -1,53 +1,20 @@
-use loam_sdk::{
-    loamstorage, log,
-    soroban_sdk::{self, env, Address, LoamKey, PersistentMap, String},
-};
+use loam_sdk::soroban_sdk::{self, env, Address, String};
 
 use crate::{
     error::Error,
-    metadata::{ContractMetadata, PublishedContract, PublishedWasm},
+    metadata::{Metadata, PublishedWasm, Wasm},
     version::{self, Version, INITAL_VERSION},
 };
 
 use super::IsPublishable;
 
-#[loamstorage]
-
-pub struct Wasm {
-    registry: PersistentMap<String, PublishedContract>,
-}
-
-impl Wasm {
-    pub fn find_contract(&self, name: String) -> Result<PublishedContract, Error> {
-        self.registry
-            .get(name)
-            .ok_or(Error::NoSuchContractPublished)
-    }
-
-    pub fn find_version(
-        &self,
-        name: String,
-        version: Option<Version>,
-    ) -> Result<PublishedWasm, Error> {
-        self.find_contract(name)?.get(version)
-    }
-
-    pub fn set_contract(&mut self, name: String, contract: &PublishedContract) {
-        self.registry.set(name, contract);
-    }
-}
-
-impl IsPublishable for Wasm {
-    fn fetch(
-        &self,
-        contract_name: String,
-        version: Option<Version>,
-    ) -> Result<PublishedWasm, Error> {
-        self.find_version(contract_name, version)
+impl IsPublishable for PublishedWasm {
+    fn fetch(&self, contract_name: String, version: Option<Version>) -> Result<Wasm, Error> {
+        self.get(&contract_name, version)
     }
 
     fn current_version(&self, contract_name: String) -> Result<Version, Error> {
-        self.find_contract(contract_name)?.most_recent_version()
+        self.most_recent_version(&contract_name)
     }
 
     fn publish(
@@ -70,34 +37,31 @@ impl IsPublishable for Wasm {
         repo: Option<soroban_sdk::String>,
         kind: Option<version::Update>,
     ) -> Result<(), Error> {
-        let mut contract = self
-            .find_contract(wasm_name.clone())
-            .unwrap_or_else(|_| PublishedContract::new(author.clone()));
-
-        if author != contract.author {
-            return Err(Error::AlreadyPublished);
+        if let Some(cunnet_author) = self.author(&wasm_name) {
+            if author != cunnet_author {
+                return Err(Error::AlreadyPublished);
+            }
         }
-        contract.author.require_auth();
 
-        let keys = contract.versions.keys();
-        let last_version = keys.last().unwrap_or_default();
+        author.require_auth();
+
+        let last_version: Version = self.most_recent_version(&wasm_name).unwrap_or_default();
         last_version.log();
         let new_version = last_version.clone().update(&kind.unwrap_or_default());
         new_version.log();
 
         let metadata = if let Some(repo) = repo {
-            ContractMetadata { repo }
+            Metadata { repo }
         } else if new_version == INITAL_VERSION {
-            ContractMetadata::default()
+            Metadata::default()
         } else {
-            contract.get(Some(last_version))?.metadata
+            self.get(&wasm_name, Some(last_version))?.metadata
         };
-        let published_binary = PublishedWasm {
+        let published_binary = Wasm {
             hash: wasm_hash,
             metadata,
         };
-        contract.versions.set(new_version, published_binary);
-        self.set_contract(wasm_name, &contract);
-        Ok(())
+        self.set_most_recent_version(&wasm_name, new_version.clone());
+        self.set(wasm_name, Some(new_version), published_binary)
     }
 }

contracts/registry/src/test.rs

@@ -32,21 +32,20 @@ fn handle_error_cases() {
     let name = &to_string("publisher");
     assert_matches!(
         client.try_fetch(name, &None).unwrap_err(),
-        Ok(Error::NoSuchContractPublished)
+        Ok(Error::NoSuchVersion)
     );
 
     let wasm_hash = env.deployer().upload_contract_wasm(loam_registry::WASM);
 
     assert_matches!(
         client.try_fetch(name, &None).unwrap_err(),
-        Ok(Error::NoSuchContractPublished)
+        Ok(Error::NoSuchVersion)
     );
 
     let bytes = Bytes::from_slice(env, loam_registry::WASM);
     env.mock_all_auths();
-    let res = client.try_publish(name, address, &bytes, &None, &None);
-    res.unwrap();
-    // assert_eq!(client.try_fetch(name, &None).unwrap().unwrap().hash, wasm_hash);
+    client.publish(name, address, &bytes, &None, &None);
+    assert_eq!(client.fetch(name, &None).hash, wasm_hash);
 
     // let other_address = Address::generate(env);
     // let res = client
@@ -64,17 +63,13 @@ fn returns_most_recent_version() {
     // client.register_name(address, name);
     let bytes = Bytes::from_slice(env, loam_registry::WASM);
     env.mock_all_auths();
-    client
-        .try_publish(name, address, &bytes, &None, &None)
-        .unwrap();
+    client.publish(name, address, &bytes, &None, &None);
     let fetched_hash = client.fetch(name, &None).hash;
     let wasm_hash = env.deployer().upload_contract_wasm(loam_registry::WASM);
     assert_eq!(fetched_hash, wasm_hash);
 
     let second_hash: BytesN<32> = BytesN::random(env);
-    client
-        .try_publish_hash(name, address, &second_hash.into_val(env), &None, &None)
-        .unwrap();
+    client.publish_hash(name, address, &second_hash.into_val(env), &None, &None);
     let res = client.fetch(name, &None).hash;
     assert_eq!(res, second_hash);