CEP-96

examples/Odra.toml

@@ -96,3 +96,6 @@ fqn = "factory::token::FToken"
 
 [[contracts]]
 fqn = "factory::token::FactoryProxy"
+
+[[contracts]]
+fqn = "contracts::cep96_cep95::Cep96Cep95"

examples/src/contracts/cep96_cep95.rs

@@ -0,0 +1,178 @@
+//! An example of a CEP-95 token with CEP-96 contract metadata.
+use odra::casper_types::bytesrepr::Bytes;
+use odra::casper_types::U256;
+use odra::prelude::*;
+use odra_modules::cep95::{CEP95Interface, Cep95};
+use odra_modules::cep96::{Cep96, Cep96ContractMetadata};
+
+/// CEP-95 token with CEP-96 contract metadata.
+#[odra::module]
+pub struct Cep96Cep95 {
+    token: SubModule<Cep95>,
+    metadata: SubModule<Cep96>
+}
+
+#[odra::module]
+impl Cep96Cep95 {
+    /// Initializes the contract with CEP-95 token params and CEP-96 metadata.
+    pub fn init(
+        &mut self,
+        name: String,
+        symbol: String,
+        contract_name: Option<String>,
+        contract_description: Option<String>,
+        contract_icon_uri: Option<String>,
+        contract_project_uri: Option<String>
+    ) {
+        self.token.init(name, symbol);
+        self.metadata.init(
+            contract_name,
+            contract_description,
+            contract_icon_uri,
+            contract_project_uri
+        );
+    }
+
+    delegate! {
+        to self.token {
+            fn name(&self) -> String;
+            fn symbol(&self) -> String;
+            fn balance_of(&self, owner: Address) -> U256;
+            fn owner_of(&self, token_id: U256) -> Option<Address>;
+            fn safe_transfer_from(&mut self, from: Address, to: Address, token_id: U256, data: Option<Bytes>);
+            fn transfer_from(&mut self, from: Address, to: Address, token_id: U256);
+            fn approve(&mut self, spender: Address, token_id: U256);
+            fn revoke_approval(&mut self, token_id: U256);
+            fn approved_for(&self, token_id: U256) -> Option<Address>;
+            fn approve_for_all(&mut self, operator: Address);
+            fn revoke_approval_for_all(&mut self, operator: Address);
+            fn is_approved_for_all(&self, owner: Address, operator: Address) -> bool;
+            fn token_metadata(&self, token_id: U256) -> Vec<(String, String)>;
+        }
+    }
+
+    delegate! {
+        to self.metadata {
+            fn contract_name(&self) -> Option<String>;
+            fn contract_description(&self) -> Option<String>;
+            fn contract_icon_uri(&self) -> Option<String>;
+            fn contract_project_uri(&self) -> Option<String>;
+        }
+    }
+
+    /// Mints a new token with the given ID and metadata to the specified address.
+    pub fn mint(&mut self, to: Address, token_id: U256, metadata: Vec<(String, String)>) {
+        self.token.raw_mint(to, token_id, metadata);
+    }
+
+    /// Burns the token with the given ID.
+    pub fn burn(&mut self, token_id: U256) {
+        let owner = self.token.owner_of(token_id);
+        let caller = self.env().caller();
+        if Some(caller) == owner {
+            self.token.raw_burn(token_id);
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Cep96Cep95;
+    use crate::contracts::cep96_cep95::{Cep96Cep95HostRef, Cep96Cep95InitArgs};
+    use odra::{host::Deployer, prelude::*};
+    use odra_test;
+
+    fn deploy_contract() -> Cep96Cep95HostRef {
+        let env = odra_test::env();
+        Cep96Cep95::deploy(
+            &env,
+            Cep96Cep95InitArgs {
+                name: "TestToken".to_string(),
+                symbol: "TST".to_string(),
+                contract_name: Some("My NFT Collection".to_string()),
+                contract_description: Some("A test NFT collection".to_string()),
+                contract_icon_uri: Some("https://example.com/icon.png".to_string()),
+                contract_project_uri: Some("https://example.com".to_string())
+            }
+        )
+    }
+
+    #[test]
+    fn test_cep96_metadata() {
+        let contract = deploy_contract();
+
+        // Verify all CEP-96 metadata fields
+        assert_eq!(
+            contract.contract_name(),
+            Some("My NFT Collection".to_string())
+        );
+        assert_eq!(
+            contract.contract_description(),
+            Some("A test NFT collection".to_string())
+        );
+        assert_eq!(
+            contract.contract_icon_uri(),
+            Some("https://example.com/icon.png".to_string())
+        );
+        assert_eq!(
+            contract.contract_project_uri(),
+            Some("https://example.com".to_string())
+        );
+    }
+
+    #[test]
+    fn test_cep96_partial_metadata() {
+        let env = odra_test::env();
+        let contract = Cep96Cep95::deploy(
+            &env,
+            Cep96Cep95InitArgs {
+                name: "TestToken".to_string(),
+                symbol: "TST".to_string(),
+                contract_name: Some("Partial Collection".to_string()),
+                contract_description: None,
+                contract_icon_uri: None,
+                contract_project_uri: Some("https://example.com".to_string())
+            }
+        );
+
+        // Only set fields should have values
+        assert_eq!(
+            contract.contract_name(),
+            Some("Partial Collection".to_string())
+        );
+        assert_eq!(contract.contract_description(), None);
+        assert_eq!(contract.contract_icon_uri(), None);
+        assert_eq!(
+            contract.contract_project_uri(),
+            Some("https://example.com".to_string())
+        );
+    }
+
+    #[test]
+    fn test_cep95_with_cep96() {
+        let env = odra_test::env();
+        let mut contract = deploy_contract();
+
+        // CEP-95 functionality should work
+        assert_eq!(contract.name(), "TestToken");
+        assert_eq!(contract.symbol(), "TST");
+
+        // Mint a token
+        let owner = env.caller();
+        let token_id = 1.into();
+        contract.mint(
+            owner,
+            token_id,
+            vec![("key".to_string(), "value".to_string())]
+        );
+
+        assert_eq!(contract.owner_of(token_id), Some(owner));
+        assert_eq!(contract.balance_of(owner), 1.into());
+
+        // CEP-96 metadata should still be accessible
+        assert_eq!(
+            contract.contract_name(),
+            Some("My NFT Collection".to_string())
+        );
+    }
+}

examples/src/contracts/mod.rs

@@ -1,5 +1,6 @@
 //! Module containing examples of contracts written in Odra.
 pub mod balance_checker;
+pub mod cep96_cep95;
 pub mod owned_cep95;
 pub mod owned_token;
 pub mod tlw;

modules/src/cep96.rs

@@ -0,0 +1,72 @@
+#![allow(unused_variables, missing_docs)]
+
+mod storage;
+
+use odra::prelude::*;
+
+use crate::cep96::storage::{
+    Cep96DescriptionStorage, Cep96IconUriStorage, Cep96NameStorage, Cep96ProjectUriStorage
+};
+pub trait Cep96ContractMetadata {
+    /// Contract's human-readable name.
+    fn contract_name(&self) -> Option<String>;
+
+    /// Brief description of the contract.
+    fn contract_description(&self) -> Option<String>;
+
+    /// URI pointing to the contract's icon image.
+    fn contract_icon_uri(&self) -> Option<String>;
+
+    /// URI pointing to the project's website or documentation.
+    fn contract_project_uri(&self) -> Option<String>;
+}
+
+#[odra::module]
+pub struct Cep96 {
+    pub contract_name: SubModule<Cep96NameStorage>,
+    pub contract_description: SubModule<Cep96DescriptionStorage>,
+    pub contract_icon_uri: SubModule<Cep96IconUriStorage>,
+    pub contract_project_uri: SubModule<Cep96ProjectUriStorage>
+}
+
+#[odra::module]
+impl Cep96ContractMetadata for Cep96 {
+    fn contract_name(&self) -> Option<String> {
+        self.contract_name.get()
+    }
+
+    fn contract_description(&self) -> Option<String> {
+        self.contract_description.get()
+    }
+
+    fn contract_icon_uri(&self) -> Option<String> {
+        self.contract_icon_uri.get()
+    }
+
+    fn contract_project_uri(&self) -> Option<String> {
+        self.contract_project_uri.get()
+    }
+}
+
+impl Cep96 {
+    pub fn init(
+        &self,
+        name: Option<String>,
+        description: Option<String>,
+        icon_uri: Option<String>,
+        project_uri: Option<String>
+    ) {
+        if let Some(name) = name {
+            self.contract_name.set(name);
+        }
+        if let Some(description) = description {
+            self.contract_description.set(description);
+        }
+        if let Some(icon_uri) = icon_uri {
+            self.contract_icon_uri.set(icon_uri);
+        }
+        if let Some(project_uri) = project_uri {
+            self.contract_project_uri.set(project_uri);
+        }
+    }
+}

modules/src/cep96/storage.rs

@@ -0,0 +1,62 @@
+use odra::prelude::*;
+
+const KEY_CONTRACT_NAME: &str = "contract_name";
+const KEY_CONTRACT_DESCRIPTION: &str = "contract_description";
+const KEY_CONTRACT_ICON_URI: &str = "contract_icon_uri";
+const KEY_CONTRACT_PROJECT_URI: &str = "contract_project_uri";
+
+#[odra::module]
+pub struct Cep96NameStorage;
+impl Cep96NameStorage {
+    pub fn set(&self, value: String) {
+        if self.get().is_none() {
+            self.env().set_named_value(KEY_CONTRACT_NAME, value);
+        }
+    }
+
+    pub fn get(&self) -> Option<String> {
+        self.env().get_named_value(KEY_CONTRACT_NAME)
+    }
+}
+
+#[odra::module]
+pub struct Cep96DescriptionStorage;
+impl Cep96DescriptionStorage {
+    pub fn set(&self, value: String) {
+        if self.get().is_none() {
+            self.env().set_named_value(KEY_CONTRACT_DESCRIPTION, value);
+        }
+    }
+
+    pub fn get(&self) -> Option<String> {
+        self.env().get_named_value(KEY_CONTRACT_DESCRIPTION)
+    }
+}
+
+#[odra::module]
+pub struct Cep96IconUriStorage;
+impl Cep96IconUriStorage {
+    pub fn set(&self, value: String) {
+        if self.get().is_none() {
+            self.env().set_named_value(KEY_CONTRACT_ICON_URI, value);
+        }
+    }
+
+    pub fn get(&self) -> Option<String> {
+        self.env().get_named_value(KEY_CONTRACT_ICON_URI)
+    }
+}
+
+#[odra::module]
+pub struct Cep96ProjectUriStorage;
+impl Cep96ProjectUriStorage {
+    pub fn set(&self, value: String) {
+        if self.get().is_none() {
+            self.env().set_named_value(KEY_CONTRACT_PROJECT_URI, value);
+        }
+    }
+
+    pub fn get(&self) -> Option<String> {
+        self.env().get_named_value(KEY_CONTRACT_PROJECT_URI)
+    }
+}

modules/src/lib.rs

@@ -8,6 +8,7 @@ pub mod access;
 pub mod cep18;
 pub mod cep18_token;
 pub mod cep95;
+pub mod cep96;
 pub mod erc1155;
 pub mod erc1155_receiver;
 pub mod erc1155_token;

odra-wasm-client-builder/Cargo.toml

@@ -17,7 +17,7 @@ convert_case = { workspace = true }
 proc-macro2 = { workspace = true }
 quote = { workspace = true }
 serde_json = { workspace = true }
-syn = { workspace = true }
+syn = { workspace = true, features = ["full", "extra-traits"] }
 thiserror = { workspace = true }
 
 [dev-dependencies]