Merge pull request #3 from rmrk-team/feature/add-uniques-ce

Add chain extension for Uniques's pallet

contracts/rmrk/Cargo.toml

@@ -17,6 +17,7 @@ scale-info = { version = "2", default-features = false, features = ["derive"], o
 
 openbrush = { version = "2.2.0", default-features = false, features = ["ownable", "psp34"] }
 rmrk = { path = "../../logics", default-features = false }
+uniques_extension = { path = "../../logics/uniques_extension", default-features = false }
 
 [lib]
 path = "lib.rs"
@@ -35,6 +36,6 @@ std = [
     "scale-info",
     "scale-info/std",
     "openbrush/std",
-    "rmrk/std"
+    "rmrk/std",
 ]
 ink-as-dependency = []

contracts/rmrk/lib.rs

@@ -5,7 +5,8 @@
 pub mod rmrk_contract {
     // imports from ink!
     use ink_env;
-    use ink_prelude::string::String;
+    use ink_prelude::string::{String, ToString};
+    use ink_prelude::vec::Vec;
     use ink_storage::traits::SpreadAllocate;
     // imports from openbrush
     use openbrush::{
@@ -16,6 +17,10 @@ pub mod rmrk_contract {
     // local imports
     use rmrk::impls::rmrk::*;
     use rmrk::traits::mint::*;
+    use uniques_extension::*;
+
+    // set CollectionDeposit to the value defined in the node runtime
+    pub const COLLECTION_DEPOSIT: Balance = 10 * 1_000_000_000_000_000;
 
     #[ink(storage)]
     #[derive(Default, SpreadAllocate, Storage)]
@@ -33,13 +38,12 @@ pub mod rmrk_contract {
     }
 
     // Section contains default implementation without any modifications
-    impl PSP34 for Rmrk {}
     impl Ownable for Rmrk {}
     impl PSP34Metadata for Rmrk {}
     impl RmrkMintable for Rmrk {}
 
     impl Rmrk {
-        #[ink(constructor)]
+        #[ink(constructor, payable)]
         pub fn new(
             name: String,
             symbol: String,
@@ -49,6 +53,7 @@ pub mod rmrk_contract {
             base_uri: String,
             _royalty_receiver: AccountId,
             _royalty: u8,
+            tmp_collection_id: u32,
         ) -> Self {
             ink_env::debug_println!("####### initializing RMRK contract");
             ink_lang::codegen::initialize_contract(|_instance: &mut Rmrk| {
@@ -57,27 +62,99 @@ pub mod rmrk_contract {
                 _instance._set_attribute(
                     collection_id.clone(),
                     String::from("name").into_bytes(),
-                    String::from(name).into_bytes(),
+                    name.into_bytes(),
                 );
                 _instance._set_attribute(
                     collection_id.clone(),
                     String::from("symbol").into_bytes(),
-                    String::from(symbol).into_bytes(),
+                    symbol.into_bytes(),
                 );
 
                 _instance._set_attribute(
                     collection_id.clone(),
                     String::from("baseUri").into_bytes(),
-                    String::from(base_uri).into_bytes(),
+                    base_uri.into_bytes(),
                 );
                 _instance._set_attribute(
                     collection_id.clone(),
                     String::from("collection_metadata").into_bytes(),
-                    String::from(collection_metadata).into_bytes(),
+                    collection_metadata.into_bytes(),
                 );
                 _instance.minting.max_supply = max_supply;
                 _instance.minting.price_per_mint = _price_per_mint;
+
+                assert!(_instance.env().transferred_value() >= COLLECTION_DEPOSIT);
+                if let Id::Bytes(data) = collection_id {
+                    let collection = u32::from_le_bytes(data[0..4].try_into().unwrap());
+                    // _instance.minting.rmrk_collection_id = collection.clone(); TODO use this after uniques supports collection_id as input
+                    _instance.minting.rmrk_collection_id = tmp_collection_id;
+                    let create_result = UniquesExt::create(collection);
+                    ink_env::debug_println!(
+                        "####### initializing RMRK contract, create_result: {:?}",
+                        create_result
+                    );
+                }
             })
         }
     }
+
+    impl PSP34 for Rmrk {
+        #[ink(message)]
+        fn transfer(&mut self, to: AccountId, id: Id, data: Vec<u8>) -> Result<(), PSP34Error> {
+            ink_env::debug_println!(
+                "####### transfer ({:?},{:?}) to:{:?}",
+                self.minting.rmrk_collection_id,
+                id,
+                to
+            );
+            self._transfer_token(to, id.clone(), data)?;
+            ink_env::debug_println!("####### _transfer_token OK");
+            if let Id::U64(token_id) = id {
+                if token_id > u32::MAX as u64 {
+                    return Err(PSP34Error::Custom("TokenIdOverflow".to_string()));
+                }
+                // Uniques pallet is defined to take u32 as item/token id
+                UniquesExt::transfer(self.minting.rmrk_collection_id, token_id as u32, to)
+                    .map_err(|_| PSP34Error::Custom("UniquesTransferFailed".to_string()))?;
+                ink_env::debug_println!("####### transfer OK");
+                return Ok(());
+            }
+            ink_env::debug_println!("####### !!!!! TransferFailed");
+            Err(PSP34Error::Custom("TransferFailed".to_string()))
+        }
+
+        #[ink(message)]
+        fn approve(
+            &mut self,
+            operator: AccountId,
+            id: Option<Id>,
+            approved: bool,
+        ) -> Result<(), PSP34Error> {
+            ink_env::debug_println!(
+                "####### approve ({:?},{:?}) approved{:?} operator:{:?}",
+                self.minting.rmrk_collection_id,
+                id,
+                approved,
+                operator,
+            );
+            self._approve_for(operator, id.clone(), approved)?;
+            ink_env::debug_println!("####### _approve_for OK");
+            if let Some(Id::U64(token_id)) = id {
+                if token_id > u32::MAX as u64 {
+                    return Err(PSP34Error::Custom("TokenIdOverflow".to_string()));
+                }
+                // Uniques pallet is defined to take u32 as item/token id
+                UniquesExt::approve_transfer(
+                    self.minting.rmrk_collection_id,
+                    token_id as u32,
+                    operator,
+                )
+                .map_err(|_| PSP34Error::Custom("UniquesApproveFailed".to_string()))?;
+                ink_env::debug_println!("####### approve OK");
+                return Ok(());
+            }
+            ink_env::debug_println!("####### !!!!! ApproveFailed");
+            Err(PSP34Error::Custom("ApproveFailed".to_string()))
+        }
+    }
 }

logics/Cargo.toml

@@ -17,6 +17,7 @@ scale-info = { version = "2", default-features = false, features = ["derive"], o
 
 openbrush = { version = "2.2.0", default-features = false, features = ["psp34", "ownable", "reentrancy_guard"] }
 primitive-types = { version = "0.11.1", default-features = false, features = ["num-traits"] }
+uniques_extension = { path = "uniques_extension", default-features = false }
 
 [lib]
 path = "lib.rs"
@@ -35,5 +36,6 @@ std = [
     "scale-info",
     "scale-info/std",
     "openbrush/std",
-    "primitive-types/std"
+    "primitive-types/std",
+    "uniques_extension/std",
 ]

logics/impls/rmrk/data.rs

@@ -8,4 +8,5 @@ pub struct Data {
     pub max_supply: u64,
     pub price_per_mint: Balance,
     pub last_minted_token_id: u64,
+    pub rmrk_collection_id: u32,
 }

logics/traits/errors.rs → logics/impls/rmrk/errors.rs

@@ -2,6 +2,7 @@ use openbrush::contracts::{
     reentrancy_guard::*,
     traits::{ownable::*, pausable::*, psp34::PSP34Error},
 };
+use uniques_extension::UniquesError;
 
 #[derive(Debug, PartialEq, Eq, scale::Encode, scale::Decode)]
 #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
@@ -10,6 +11,7 @@ pub enum RmrkError {
     OwnableError(OwnableError),
     PausableError(PausableError),
     ReentrancyGuardError(ReentrancyGuardError),
+    UniquesError(UniquesError),
     CannotMintZeroTokens,
     CollectionFullOrLocked,
     MintUnderpriced,

logics/impls/rmrk/mint.rs

@@ -1,9 +1,8 @@
 use crate::impls::rmrk::data;
-pub use crate::traits::{
-    errors::RmrkError,
-    mint::{RmrkMintable, RmrkMintableRef},
-};
+use crate::impls::rmrk::errors::RmrkError;
+pub use crate::traits::mint::{RmrkMintable, RmrkMintableRef};
 use ink_prelude::string::{String, ToString};
+use uniques_extension::*;
 
 use openbrush::{
     contracts::{psp34::*, reentrancy_guard::*},
@@ -44,11 +43,20 @@ where
 
         for mint_id in next_to_mint..mint_offset {
             ink_env::debug_println!("####### mint id:{:?}", mint_id);
+            // mint in this contract
             assert!(self
                 .data::<psp34::Data>()
                 ._mint_to(to, Id::U64(mint_id))
                 .is_ok());
             self.data::<data::Data>().last_minted_token_id += 1;
+
+            // mint in pallet
+            let mint_result = UniquesExt::mint(
+                self.data::<data::Data>().rmrk_collection_id, // collection_id
+                mint_id.try_into().unwrap(),                  // item_id
+                to,
+            );
+            ink_env::debug_println!("####### minting in pallet, mint_result: {:?}", mint_result);
         }
 
         Ok(())

logics/impls/rmrk/mod.rs

@@ -1,2 +1,3 @@
 pub mod data;
+pub mod errors;
 pub mod mint;

logics/traits/mint.rs

@@ -1,5 +1,4 @@
-use crate::traits::errors::RmrkError;
-// use openbrush::contracts::psp34::*;
+use crate::impls::rmrk::errors::RmrkError;
 use ink_prelude::string::String;
 use openbrush::{
     modifiers,
@@ -16,6 +15,7 @@ pub trait RmrkMintable {
     #[modifiers(non_reentrant)]
     fn mint(&mut self, to: AccountId, mint_amount: u64) -> Result<(), RmrkError>;
 
+    // #[ink(message)]
     // fn nft_mint_directly_to_nft(&self, parent: AccountIdOrCollectionNftTuple) -> Result<(), RmrkError>;
 
     /// Maximum amount of mintable tokens in this contract

logics/traits/mod.rs

@@ -1,2 +1 @@
-pub mod errors;
 pub mod mint;

logics/uniques_extension/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "uniques_extension"
+version = "0.1.0"
+authors = ["Stake Technologies <devops@stake.co.jp>"]
+edition = "2021"
+
+[dependencies]
+ink_primitives = { version = "~3.3.1", default-features = false }
+ink_metadata = { version = "~3.3.1", default-features = false, features = ["derive"], optional = true }
+ink_env = { version = "~3.3.1", default-features = false }
+ink_storage = { version = "~3.3.1",default-features = false }
+ink_lang = { version = "~3.3.1", default-features = false }
+ink_prelude = { version = "~3.3.1", default-features = false }
+
+scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
+scale-info = { version = "2", default-features = false, features = ["derive"], optional = true }
+
+[lib]
+name = "uniques_extension"
+path = "lib.rs"
+crate-type = ["rlib"]
+
+[features]
+default = ["std"]
+std = [
+    "ink_metadata/std",
+    "ink_env/std",
+    "ink_storage/std",
+    "ink_primitives/std",
+    "scale/std",
+    "scale-info/std"
+]
+ink-as-dependency = []