git.delta.rocks / unique-network / refs/commits / 172f80a3eea4

1117
1118            let sender = ensure_signed(origin)?;1117            let sender = ensure_signed(origin)?;
1119
1120            let target_collection = Self::get_collection(collection_id)?;1118            Self::create_item_internal(sender, collection_id, owner, data)
1121
1122            Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;
1123            Self::validate_create_item_args(&target_collection, &data)?;
1124            Self::create_item_no_validation(&target_collection, owner, data)?;
1125
1126            Ok(())
1127        }1119        }
11281120
1129        /// This method creates multiple items in a collection created with CreateCollection method.1121        /// This method creates multiple items in a collection created with CreateCollection method.
1763}1755}
17641756
1765impl<T: Config> Module<T> {1757impl<T: Config> Module<T> {
1758    pub fn create_item_internal(sender: T::AccountId, collection_id: CollectionId, owner: T::AccountId, data: CreateItemData) -> DispatchResult {
1759        let target_collection = Self::get_collection(collection_id)?;
1760
1761        Self::can_create_items_in_collection(&target_collection, &sender, &owner, 1)?;
1762        Self::validate_create_item_args(&target_collection, &data)?;
1763        Self::create_item_no_validation(&target_collection, owner, data)?;
1764
1765        Ok(())
1766    }
17661767
1767    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {1768    pub fn transfer_internal(sender: T::AccountId, recipient: T::AccountId, target_collection: &CollectionHandle<T>, item_id: TokenId, value: u128) -> DispatchResult {
1768        // Limits check1769        // Limits check

--- a/runtime/src/chain_extension.rs
+++ b/runtime/src/chain_extension.rs
@@ -21,6 +21,14 @@
 use sp_runtime::AccountId32;
 use crate::Vec;
 
+/// Create item parameters
+#[derive(Debug, PartialEq, Encode, Decode)]
+pub struct NFTExtCreateItem<E: Ext> {
+    pub owner: <E::T as SysConfig>::AccountId,
+    pub collection_id: u32,
+    pub data: CreateItemData,
+}
+
 /// Transfer parameters
 #[derive(Debug, PartialEq, Encode, Decode)]
 pub struct NFTExtTransfer<E: Ext> {
@@ -36,6 +44,7 @@
 impl<C: Config> ChainExtension<C> for NFTExtension {
     fn call<E: Ext>(func_id: u32, env: Environment<E, InitState>) -> Result<RetVal, DispatchError>
     where
+        E: Ext<T = C>,
         <E::T as SysConfig>::AccountId: UncheckedFrom<<E::T as SysConfig>::Hash> + AsRef<[u8]>,
     {
         // The memory of the vm stores buf in scale-codec
@@ -44,31 +53,36 @@
                 let mut env = env.buf_in_buf_out();
                 let input: NFTExtTransfer<E> = env.read_as()?;
 
-                // Sender to AccountId32
-                let mut bytes_sender: [u8; 32] = [0; 32];
-                let addr_vec_sender: Vec<u8> = env.ext().caller().encode();
-                for i in 0..32 {
-                    bytes_sender[i] = addr_vec_sender[i];
-                }
-                let sender = AccountId32::from(bytes_sender);
+                let collection = pallet_nft::Module::<C>::get_collection(input.collection_id)?;
 
-                // Recipient to AccountId32
-                let mut bytes_rec: [u8; 32] = [0; 32];
-                let addr_vec_rec: Vec<u8> = input.recipient.encode();
-                for i in 0..32 {
-                    bytes_rec[i] = addr_vec_rec[i];
+                match pallet_nft::Module::<C>::transfer_internal(
+                    env.ext().caller().clone(),
+                    input.recipient,
+                    &collection,
+                    input.token_id,
+                    input.amount,
+                ) {
+                    Ok(_) => Ok(RetVal::Converging(func_id)),
+                    _ => Err(DispatchError::Other("Transfer error"))
                 }
-                let recipient = AccountId32::from(bytes_rec);
+            },
+            1 => {
+                // Create Item
+                let mut env = env.buf_in_buf_out();
+                let input: NFTExtCreateItem<E> = env.read_as()?;
 
-                let collection = pallet_nft::Module::<Runtime>::get_collection(input.collection_id)?;
-
-                match pallet_nft::Module::<Runtime>::transfer_internal(sender, recipient, &collection, input.token_id, input.amount) {
+                match pallet_nft::Module::<C>::create_item_internal(
+                    env.ext().address().clone(),
+                    input.collection_id,
+                    input.owner,
+                    input.data,
+                ) {
                     Ok(_) => Ok(RetVal::Converging(func_id)),
-                    _ => Err(DispatchError::Other("Transfer error"))
+                    _ => Err(DispatchError::Other("CreateItem error"))
                 }
             },
-			_ => {
-				panic!("Passed unknown func_id to test chain extension: {}", func_id);
+            _ => {
+                panic!("Passed unknown func_id to test chain extension: {}", func_id);
             }
         }
     }