fix: try to minimize the key sizes

Author: willemneal

contracts/registry/src/lib.rs

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

contracts/registry/src/metadata.rs

@@ -1,5 +1,23 @@
-mod contract;
-pub use contract::*;
+use loam_sdk::soroban_sdk::{self, contracttype, to_string, BytesN, String};
 
-pub mod wasm;
-pub use wasm::*;
+
+
+#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Default)]
+#[contracttype]
+pub struct Metadata {
+    pub repo: Option<String>,
+}
+
+impl Metadata {
+    pub fn new(repo: String) -> Self {
+        Self { repo: Some(repo)  }
+    }
+}
+
+/// Contains info about specific version of published binary
+#[contracttype]
+#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd,)]
+pub struct PublishedWasm {
+    pub hash: BytesN<32>,
+    pub metadata: Metadata,
+}

contracts/registry/src/metadata/contract.rs

@@ -8,6 +8,9 @@ use crate::{
 pub mod contract;
 pub mod wasm;
 
+pub use contract::Contract;
+pub use wasm::Wasm;
+
 #[loam_sdk::subcontract]
 pub trait IsPublishable {
     /// Fetch the hash from the registry
@@ -27,7 +30,7 @@ pub trait IsPublishable {
         &self,
         contract_name: soroban_sdk::String,
         version: Option<Version>,
-    ) -> Result<crate::metadata::Wasm, Error>;
+    ) -> Result<crate::metadata::PublishedWasm, Error>;
 
     /// Publish a binary. If contract had been previously published only previous author can publish again
     fn publish(

contracts/registry/src/metadata/wasm.rs

@@ -8,11 +8,11 @@ use loam_sdk::{
 };
 
 use crate::{
-    error::Error, metadata::PublishedWasm, registry::Publishable, util::hash_string,
+    error::Error, registry::Publishable, util::hash_string,
     version::Version, Contract as Contract_,
 };
 
-use super::{IsClaimable, IsDeployable, IsDevDeployable};
+use super::{wasm::Wasm, IsClaimable, IsDeployable, IsDevDeployable};
 
 loam_sdk::import_contract!(example_core);
 
@@ -87,7 +87,7 @@ impl IsDeployable for Contract {
         // Publish a deploy event
         let version = version.map_or_else(
             || {
-                PublishedWasm::default().most_recent_version(&contract_name)
+                Wasm::default().most_recent_version(&contract_name)
             },
             Ok,
         )?;

contracts/registry/src/registry.rs

@@ -1,15 +1,73 @@
-use loam_sdk::soroban_sdk::{self, env, Address, String};
+use loam_sdk::{loamstorage, soroban_sdk::{self, env, Address, LoamKey, PersistentMap, String}};
 
 use crate::{
     error::Error,
-    metadata::{Metadata, PublishedWasm, Wasm},
+    metadata::{Metadata, PublishedWasm},
     version::{self, Version, INITAL_VERSION},
 };
 
 use super::IsPublishable;
 
-impl IsPublishable for PublishedWasm {
-    fn fetch(&self, contract_name: String, version: Option<Version>) -> Result<Wasm, Error> {
+/// Contains
+#[loamstorage]
+pub struct Wasm {
+    pub versions: PersistentMap<(String, Version), PublishedWasm>,
+    pub author: PersistentMap<String, Address>,
+    pub most_recent_version: PersistentMap<String, Version>,
+}
+
+impl Wasm {
+    pub fn new(name: &String, author: Address) -> Self {
+        let mut s = Self::default();
+        s.author.set(name.clone(), &author);
+        s
+    }
+}
+
+impl Wasm {
+    pub fn most_recent_version(&self, name: &String) -> Result<Version, Error> {
+        self.most_recent_version
+            .get(name.clone())
+            .ok_or(Error::NoSuchVersion)
+    }
+
+    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<PublishedWasm, Error> {
+        let version = if let Some(version) = version {
+            version
+        } else {
+            self.most_recent_version(name)?
+        };
+        self.versions
+            .get((name.clone(), version))
+            .ok_or(Error::NoSuchVersion)
+    }
+
+    pub fn set(
+        &mut self,
+        name: String,
+        version: Option<Version>,
+        binary: PublishedWasm,
+    ) -> Result<(), Error> {
+        let version = if let Some(version) = version {
+            version
+        } else {
+            self.most_recent_version(&name)?
+        };
+        self.versions.set((name, version), &binary);
+        Ok(())
+    }
+
+    pub fn author(&self, name: &String) -> Option<Address> {
+        self.author.get(name.clone())
+    }
+}
+
+impl IsPublishable for Wasm {
+    fn fetch(&self, contract_name: String, version: Option<Version>) -> Result<PublishedWasm, Error> {
         self.get(&contract_name, version)
     }
 
@@ -51,13 +109,13 @@ impl IsPublishable for PublishedWasm {
         new_version.log();
 
         let metadata = if let Some(repo) = repo {
-            Metadata { repo }
+            Metadata::new(repo)
         } else if new_version == INITAL_VERSION {
             Metadata::default()
         } else {
             self.get(&wasm_name, Some(last_version))?.metadata
         };
-        let published_binary = Wasm {
+        let published_binary = PublishedWasm {
             hash: wasm_hash,
             metadata,
         };

contracts/registry/src/registry/contract.rs

@@ -5,17 +5,10 @@ use loam_sdk::soroban_sdk::{self, contracttype, env, log, Env};
 /// Represents the version of the contract
 #[contracttype]
 #[derive(Default, Eq, PartialEq, Clone, Debug)]
-pub struct Version {
-    patch: u32,
-    minor: u32,
-    major: u32,
-}
+pub struct Version(u32, u32, u32);
+
 
-pub const INITAL_VERSION: Version = Version {
-    major: 0,
-    minor: 0,
-    patch: 1,
-};
+pub const INITAL_VERSION: Version = Version(0,0,1);
 
 impl Display for Version {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
@@ -30,21 +23,21 @@ impl Version {
 
     #[must_use]
     pub fn publish_patch(mut self) -> Self {
-        self.patch += 1;
+        self.2 += 1;
         self
     }
 
     #[must_use]
     pub fn publish_minor(mut self) -> Self {
-        self.minor += 1;
-        self.patch = 0;
+        self.1 += 1;
+        self.2 = 0;
         self
     }
     #[must_use]
     pub fn publish_major(mut self) -> Self {
-        self.major += 1;
-        self.minor = 0;
-        self.patch = 0;
+        self.0 += 1;
+        self.1 = 0;
+        self.2 = 0;
         self
     }
 
@@ -57,15 +50,15 @@ impl Version {
         }
     }
     pub fn patch(&self) -> u32 {
-        self.patch
+        self.2
     }
 
     pub fn minor(&self) -> u32 {
-        self.minor
+        self.1
     }
 
     pub fn major(&self) -> u32 {
-        self.major
+        self.0
     }
 }