lib.rs

// This file is part of galacticcouncil/warehouse.

// Copyright (C) 2020-2022  Intergalactic, Limited (GIB).
// SPDX-License-Identifier: Apache-2.0

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#![cfg_attr(not(feature = "std"), no_std)]
#![allow(clippy::unused_unit)]
#![allow(clippy::upper_case_acronyms)]

use codec::HasCompact;
use frame_support::{
    dispatch::DispatchResult,
    ensure,
    traits::{tokens::nonfungibles::*, Get},
    BoundedVec,
};
use frame_system::ensure_signed;
use pallet_uniques::DestroyWitness;

use hydradx_traits::nft::{CreateTypedCollection, ReserveCollectionId};
use sp_runtime::{
    traits::{AtLeast32BitUnsigned, StaticLookup, Zero},
    DispatchError,
};
use sp_std::boxed::Box;
pub use types::*;
use weights::WeightInfo;

mod benchmarking;
pub mod migration;
pub mod types;
pub mod weights;

#[cfg(test)]
pub mod mock;

#[cfg(test)]
mod tests;

pub type BoundedVecOfUnq<T> = BoundedVec<u8, <T as pallet_uniques::Config>::StringLimit>;
type CollectionInfoOf<T> = CollectionInfo<<T as Config>::CollectionType, BoundedVecOfUnq<T>>;
pub type ItemInfoOf<T> = ItemInfo<BoundedVec<u8, <T as pallet_uniques::Config>::StringLimit>>;

// Re-export pallet items so that they can be accessed from the crate namespace.
pub use pallet::*;

#[frame_support::pallet]
pub mod pallet {

    use super::*;
    use frame_support::pallet_prelude::*;
    use frame_system::pallet_prelude::OriginFor;

    const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);

    #[pallet::pallet]
    #[pallet::storage_version(STORAGE_VERSION)]
    #[pallet::generate_store(pub(super) trait Store)]
    pub struct Pallet<T>(_);

    #[pallet::config]
    pub trait Config: frame_system::Config + pallet_uniques::Config {
        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
        type WeightInfo: WeightInfo;
        type NftCollectionId: Member
            + Parameter
            + Default
            + Copy
            + HasCompact
            + AtLeast32BitUnsigned
            + Into<Self::CollectionId>
            + From<Self::CollectionId>
            + MaxEncodedLen;
        type NftItemId: Member
            + Parameter
            + Default
            + Copy
            + HasCompact
            + AtLeast32BitUnsigned
            + Into<Self::ItemId>
            + From<Self::ItemId>
            + MaxEncodedLen;
        type CollectionType: Member + Parameter + Default + Copy + MaxEncodedLen;
        type Permissions: NftPermission<Self::CollectionType>;
        /// Collection IDs reserved for runtime up to the following constant
        #[pallet::constant]
        type ReserveCollectionIdUpTo: Get<Self::NftCollectionId>;
    }

    #[pallet::storage]
    #[pallet::getter(fn collections)]
    /// Stores collection info
    pub type Collections<T: Config> = StorageMap<_, Twox64Concat, T::NftCollectionId, CollectionInfoOf<T>>;

    #[pallet::storage]
    #[pallet::getter(fn items)]
    /// Stores item info
    pub type Items<T: Config> =
        StorageDoubleMap<_, Twox64Concat, T::NftCollectionId, Twox64Concat, T::NftItemId, ItemInfoOf<T>>;

    #[pallet::call]
    impl<T: Config> Pallet<T> {
        /// Creates an NFT collection of the given collection type and sets its metadata.
        /// The collection ID needs to be outside of the range of reserved IDs.
        /// The creation of a collection needs to be enabled in the permissions
        /// for the given collection type.
        ///
        /// Parameters:
        /// - `origin`: The owner of the newly created collection.
        /// - `collection_id`: Identifier of a collection.
        /// - `collection_type`: The collection type determines its purpose and usage.
        /// - `metadata`: Arbitrary data about a collection, e.g. IPFS hash or name.
        ///
        /// Emits CollectionCreated event
        #[pallet::call_index(0)]
        #[pallet::weight(<T as Config>::WeightInfo::create_collection())]
        pub fn create_collection(
            origin: OriginFor<T>,
            collection_id: T::NftCollectionId,
            collection_type: T::CollectionType,
            metadata: BoundedVecOfUnq<T>,
        ) -> DispatchResult {
            let sender = ensure_signed(origin)?;

            ensure!(!Self::is_id_reserved(collection_id), Error::<T>::IdReserved);
            ensure!(T::Permissions::can_create(&collection_type), Error::<T>::NotPermitted);

            Self::do_create_collection(sender, collection_id, collection_type, metadata)?;

            Ok(())
        }

        /// Mints an NFT in the specified collection and sets its metadata.
        /// Minting of new items needs to be enabled in the permissions
        /// for the given collection type.
        ///
        /// Parameters:
        /// - `origin`: The owner of the newly minted NFT.
        /// - `collection_id`: The collection of the asset to be minted.
        /// - `item_id`: The item of the asset to be minted.
        /// - `metadata`: Arbitrary data about an item, e.g. IPFS hash or symbol.
        #[pallet::call_index(1)]
        #[pallet::weight(<T as Config>::WeightInfo::mint())]
        pub fn mint(
            origin: OriginFor<T>,
            collection_id: T::NftCollectionId,
            item_id: T::NftItemId,
            metadata: BoundedVecOfUnq<T>,
        ) -> DispatchResult {
            let sender = ensure_signed(origin)?;

            let collection_type = Self::collections(collection_id)
                .map(|c| c.collection_type)
                .ok_or(Error::<T>::CollectionUnknown)?;

            ensure!(T::Permissions::can_mint(&collection_type), Error::<T>::NotPermitted);

            let collection_owner = Self::collection_owner(&collection_id).ok_or(Error::<T>::CollectionUnknown)?;
            ensure!(collection_owner == sender, Error::<T>::NotPermitted);

            Self::do_mint(sender, collection_id, item_id, metadata)?;

            Ok(())
        }

        /// Transfers NFT from account A to account B.
        /// Transfers need to be enabled in the permissions for the given collection type.
        ///
        /// Parameters:
        /// - `origin`: The NFT owner
        /// - `collection_id`: The collection of the asset to be transferred.
        /// - `item_id`: The instance of the asset to be transferred.
        /// - `dest`: The account to receive ownership of the asset.
        #[pallet::call_index(2)]
        #[pallet::weight(<T as Config>::WeightInfo::transfer())]
        pub fn transfer(
            origin: OriginFor<T>,
            collection_id: T::NftCollectionId,
            item_id: T::NftItemId,
            dest: <T::Lookup as StaticLookup>::Source,
        ) -> DispatchResult {
            let sender = ensure_signed(origin)?;

            let dest = T::Lookup::lookup(dest)?;

            let collection_type = Self::collections(collection_id)
                .map(|c| c.collection_type)
                .ok_or(Error::<T>::CollectionUnknown)?;

            ensure!(T::Permissions::can_transfer(&collection_type), Error::<T>::NotPermitted);

            Self::do_transfer(collection_id, item_id, sender, dest)?;

            Ok(())
        }

        /// Removes a token from existence.
        /// Burning needs to be enabled in the permissions for the given collection type.
        ///
        /// Parameters:
        /// - `origin`: The NFT owner.
        /// - `collection_id`: The collection of the asset to be burned.
        /// - `item_id`: The instance of the asset to be burned.
        #[pallet::call_index(3)]
        #[pallet::weight(<T as Config>::WeightInfo::burn())]
        pub fn burn(origin: OriginFor<T>, collection_id: T::NftCollectionId, item_id: T::NftItemId) -> DispatchResult {
            let sender = ensure_signed(origin)?;

            let collection_type = Self::collections(collection_id)
                .map(|c| c.collection_type)
                .ok_or(Error::<T>::CollectionUnknown)?;

            ensure!(T::Permissions::can_burn(&collection_type), Error::<T>::NotPermitted);

            Self::do_burn(sender, collection_id, item_id)?;

            Ok(())
        }

        /// Removes a collection from existence.
        /// Destroying of collections need to be enabled in the permissions
        /// for the given collection type.
        /// Fails if the collection is not empty.
        ///
        /// Parameters:
        /// - `origin`: The collection owner.
        /// - `collection_id`: The identifier of the asset collection to be destroyed.
        #[pallet::call_index(4)]
        #[pallet::weight(<T as Config>::WeightInfo::destroy_collection())]
        pub fn destroy_collection(origin: OriginFor<T>, collection_id: T::NftCollectionId) -> DispatchResult {
            let sender = ensure_signed(origin)?;

            let collection_type = Self::collections(collection_id)
                .map(|c| c.collection_type)
                .ok_or(Error::<T>::CollectionUnknown)?;

            ensure!(T::Permissions::can_destroy(&collection_type), Error::<T>::NotPermitted);

            Self::do_destroy_collection(sender, collection_id)?;

            Ok(())
        }
    }

    #[pallet::hooks]
    impl<T: Config> Hooks<T::BlockNumber> for Pallet<T> {}

    #[pallet::event]
    #[pallet::generate_deposit(pub(crate) fn deposit_event)]
    pub enum Event<T: Config> {
        /// A collection was created
        CollectionCreated {
            owner: T::AccountId,
            collection_id: T::NftCollectionId,
            collection_type: T::CollectionType,
            metadata: BoundedVecOfUnq<T>,
        },
        /// An item was minted
        ItemMinted {
            owner: T::AccountId,
            collection_id: T::NftCollectionId,
            item_id: T::NftItemId,
            metadata: BoundedVecOfUnq<T>,
        },
        /// An item was transferred
        ItemTransferred {
            from: T::AccountId,
            to: T::AccountId,
            collection_id: T::NftCollectionId,
            item_id: T::NftItemId,
        },
        /// An item was burned
        ItemBurned {
            owner: T::AccountId,
            collection_id: T::NftCollectionId,
            item_id: T::NftItemId,
        },
        /// A collection was destroyed
        CollectionDestroyed {
            owner: T::AccountId,
            collection_id: T::NftCollectionId,
        },
    }

    #[pallet::error]
    pub enum Error<T> {
        /// Count of items overflown
        NoAvailableItemId,
        /// Count of collections overflown
        NoAvailableCollectionId,
        /// Collection still contains minted tokens
        TokenCollectionNotEmpty,
        /// Collection does not exist
        CollectionUnknown,
        /// Item does not exist
        ItemUnknown,
        /// Operation not permitted
        NotPermitted,
        /// ID reserved for runtime
        IdReserved,
    }
}

impl<T: Config> Pallet<T> {
    fn do_create_collection(
        owner: T::AccountId,
        collection_id: T::NftCollectionId,
        collection_type: T::CollectionType,
        metadata: BoundedVecOfUnq<T>,
    ) -> DispatchResult {
        let deposit_info = match T::Permissions::has_deposit(&collection_type) {
            false => (Zero::zero(), true),
            true => (T::CollectionDeposit::get(), false),
        };

        pallet_uniques::Pallet::<T>::do_create_collection(
            collection_id.into(),
            owner.clone(),
            owner.clone(),
            deposit_info.0,
            deposit_info.1,
            pallet_uniques::Event::Created {
                collection: collection_id.into(),
                creator: owner.clone(),
                owner: owner.clone(),
            },
        )?;

        Collections::<T>::insert(
            collection_id,
            CollectionInfo {
                collection_type,
                metadata: metadata.clone(),
            },
        );

        Self::deposit_event(Event::CollectionCreated {
            owner,
            collection_id,
            collection_type,
            metadata,
        });

        Ok(())
    }

    fn do_mint(
        owner: T::AccountId,
        collection_id: T::NftCollectionId,
        item_id: T::NftItemId,
        metadata: BoundedVecOfUnq<T>,
    ) -> DispatchResult {
        ensure!(
            Collections::<T>::contains_key(collection_id),
            Error::<T>::CollectionUnknown
        );

        pallet_uniques::Pallet::<T>::do_mint(collection_id.into(), item_id.into(), owner.clone(), |_details| Ok(()))?;

        Items::<T>::insert(
            collection_id,
            item_id,
            ItemInfo {
                metadata: metadata.clone(),
            },
        );

        Self::deposit_event(Event::ItemMinted {
            owner,
            collection_id,
            item_id,
            metadata,
        });

        Ok(())
    }

    /// Transfer NFT from account `from` to `to`.
    /// Fails if `from` is not the NFT owner.
    ///
    /// Is a no-op if `from` is the same as `to`.
    fn do_transfer(
        collection_id: T::NftCollectionId,
        item_id: T::NftItemId,
        from: T::AccountId,
        to: T::AccountId,
    ) -> DispatchResult {
        if from == to {
            return Ok(());
        }

        let owner = Self::owner(&collection_id, &item_id).ok_or(Error::<T>::ItemUnknown)?;
        ensure!(owner == from, Error::<T>::NotPermitted);

        pallet_uniques::Pallet::<T>::do_transfer(
            collection_id.into(),
            item_id.into(),
            to.clone(),
            |_collection_details, _item_details| {
                Self::deposit_event(Event::ItemTransferred {
                    from,
                    to,
                    collection_id,
                    item_id,
                });
                Ok(())
            },
        )
    }

    fn do_burn(owner: T::AccountId, collection_id: T::NftCollectionId, item_id: T::NftItemId) -> DispatchResult {
        let item_owner = Self::owner(&collection_id, &item_id).ok_or(Error::<T>::ItemUnknown)?;
        ensure!(owner == item_owner, Error::<T>::NotPermitted);

        pallet_uniques::Pallet::<T>::do_burn(
            collection_id.into(),
            item_id.into(),
            |_collection_details, _item_details| Ok(()),
        )?;

        Items::<T>::remove(collection_id, item_id);

        Self::deposit_event(Event::ItemBurned {
            owner,
            collection_id,
            item_id,
        });

        Ok(())
    }

    fn do_destroy_collection(
        owner: T::AccountId,
        collection_id: T::NftCollectionId,
    ) -> Result<DestroyWitness, DispatchError> {
        let witness = Self::get_destroy_witness(&collection_id).ok_or(Error::<T>::CollectionUnknown)?;

        // witness struct is empty because we don't allow destroying a collection with existing items
        ensure!(witness.items == 0u32, Error::<T>::TokenCollectionNotEmpty);

        let witness =
            pallet_uniques::Pallet::<T>::do_destroy_collection(collection_id.into(), witness, Some(owner.clone()))?;
        Collections::<T>::remove(collection_id);

        Self::deposit_event(Event::CollectionDestroyed { owner, collection_id });
        Ok(witness)
    }
}

impl<T: Config> Inspect<T::AccountId> for Pallet<T> {
    type ItemId = T::NftItemId;
    type CollectionId = T::NftCollectionId;

    /// Returns the owner of `item` of `collection`, or `None` if the item doesn't exist.
    fn owner(collection: &Self::CollectionId, item: &Self::ItemId) -> Option<T::AccountId> {
        pallet_uniques::Pallet::<T>::owner((*collection).into(), (*item).into())
    }

    /// Returns the owner of the `collection`, or `None` if the collection doesn't exist.
    fn collection_owner(collection: &Self::CollectionId) -> Option<T::AccountId> {
        pallet_uniques::Pallet::<T>::collection_owner((*collection).into())
    }

    /// Returns `true` if the `item` of `collection` may be transferred.
    fn can_transfer(collection: &Self::CollectionId, _item: &Self::ItemId) -> bool {
        let maybe_collection_type = Self::collections(collection).map(|c| c.collection_type);

        match maybe_collection_type {
            Some(collection_type) => T::Permissions::can_transfer(&collection_type),
            _ => false,
        }
    }
}

impl<T: Config> InspectEnumerable<T::AccountId> for Pallet<T> {
    type CollectionsIterator = Box<dyn Iterator<Item = <T as Config>::NftCollectionId>>;
    type ItemsIterator = Box<dyn Iterator<Item = <T as Config>::NftItemId>>;
    type OwnedIterator = Box<dyn Iterator<Item = (<T as Config>::NftCollectionId, <T as Config>::NftItemId)>>;
    type OwnedInCollectionIterator = Box<dyn Iterator<Item = <T as Config>::NftItemId>>;

    /// Returns an iterator of the collections in existence.
    fn collections() -> Self::CollectionsIterator {
        Box::new(Collections::<T>::iter_keys())
    }

    /// Returns an iterator of the items of a `collection` in existence.
    fn items(collection: &Self::CollectionId) -> Self::ItemsIterator {
        Box::new(Items::<T>::iter_key_prefix(collection))
    }

    /// Returns an iterator of the items of all collections owned by `who`.
    fn owned(who: &T::AccountId) -> Self::OwnedIterator {
        Box::new(
            pallet_uniques::Pallet::<T>::owned(who)
                .map(|(collection_id, item_id)| (collection_id.into(), item_id.into())),
        )
    }

    /// Returns an iterator of the items of `collection` owned by `who`.
    fn owned_in_collection(collection: &Self::CollectionId, who: &T::AccountId) -> Self::OwnedInCollectionIterator {
        Box::new(
            pallet_uniques::Pallet::<T>::owned_in_collection(
                &(Into::<<T as pallet_uniques::Config>::CollectionId>::into(*collection)),
                who,
            )
            .map(|i| i.into()),
        )
    }
}

impl<T: Config> Destroy<T::AccountId> for Pallet<T> {
    type DestroyWitness = DestroyWitness;

    /// The witness data needed to destroy an item.
    fn get_destroy_witness(collection: &Self::CollectionId) -> Option<Self::DestroyWitness> {
        pallet_uniques::Pallet::<T>::get_destroy_witness(
            &(Into::<<T as pallet_uniques::Config>::CollectionId>::into(*collection)),
        )
    }

    /// Removes a collection from existence.
    /// Destroying of collections is not enforced by the permissions
    /// for the given collection type.
    /// Fails if the collection is not empty and contains items.
    ///
    /// Parameters:
    /// - `collection`: The `CollectionId` to be destroyed.
    /// - `witness`: Empty witness data that needs to be provided to complete the operation
    ///   successfully.
    /// - `maybe_check_owner`: An optional account id that can be used to authorize the destroy
    ///   command. If not provided, we will not do any authorization checks before destroying the
    ///   item.
    ///
    /// If successful, this function will return empty witness data from the destroyed item.
    fn destroy(
        collection: Self::CollectionId,
        _witness: Self::DestroyWitness,
        maybe_check_owner: Option<T::AccountId>,
    ) -> Result<Self::DestroyWitness, DispatchError> {
        let owner = if let Some(check_owner) = maybe_check_owner {
            check_owner
        } else {
            Self::collection_owner(&collection).ok_or(Error::<T>::CollectionUnknown)?
        };

        Self::do_destroy_collection(owner, collection)
    }
}

impl<T: Config> Mutate<T::AccountId> for Pallet<T> {
    /// Mints an NFT in the specified collection and sets its metadata.
    /// The minting permissions are not enforced.
    /// Metadata is set to the default value.
    ///
    /// Parameters:
    /// - `collection`: The collection of the asset to be minted.
    /// - `item`: The item of the asset to be minted.
    /// - `who`: The owner of the newly minted NFT.
    fn mint_into(collection: &Self::CollectionId, item: &Self::ItemId, who: &T::AccountId) -> DispatchResult {
        Self::do_mint(who.clone(), *collection, *item, BoundedVec::default())?;

        Ok(())
    }

    /// Removes an item from existence.
    /// The burning permissions are not enforced.
    ///
    /// Parameters:
    /// - `collection`: The collection of the asset to be burned.
    /// - `item`: The instance of the asset to be burned.
    /// - `maybe_check_owner`: Optional value.
    fn burn(
        collection: &Self::CollectionId,
        item: &Self::ItemId,
        maybe_check_owner: Option<&T::AccountId>,
    ) -> DispatchResult {
        let owner = if let Some(check_owner) = maybe_check_owner {
            check_owner.clone()
        } else {
            Self::owner(collection, item).ok_or(Error::<T>::ItemUnknown)?
        };

        Self::do_burn(owner, *collection, *item)?;

        Ok(())
    }
}

impl<T: Config> Transfer<T::AccountId> for Pallet<T> {
    /// Transfer `item` of `collection` into `destination` account.
    fn transfer(collection: &Self::CollectionId, item: &Self::ItemId, destination: &T::AccountId) -> DispatchResult {
        let owner = Self::owner(collection, item).ok_or(Error::<T>::ItemUnknown)?;

        Self::do_transfer(*collection, *item, owner, destination.clone())
    }
}

impl<T: Config> CreateTypedCollection<T::AccountId, T::NftCollectionId, T::CollectionType, BoundedVecOfUnq<T>>
    for Pallet<T>
{
    /// Creates an NFT collection of the given collection type and sets its metadata.
    /// The collection ID does not need to be outside of the range of reserved IDs.
    /// The permissions for the creation of a collection are not enforced.
    /// Metadata is set to the default value if not provided.
    ///
    /// Parameters:
    /// - `owner`: The collection owner.
    /// - `collection_id`: Identifier of a collection.
    /// - `collection_type`: The collection type.
    /// - `metadata`: Optional arbitrary data about a collection, e.g. IPFS hash or name.
    ///
    /// Emits CollectionCreated event
    fn create_typed_collection(
        owner: T::AccountId,
        collection_id: T::NftCollectionId,
        collection_type: T::CollectionType,
        metadata: Option<BoundedVecOfUnq<T>>,
    ) -> DispatchResult {
        Self::do_create_collection(owner, collection_id, collection_type, metadata.unwrap_or_default())
    }
}

impl<T: Config> ReserveCollectionId<T::NftCollectionId> for Pallet<T> {
    /// Checks if the provided collection ID is within the range of reserved IDs.
    fn is_id_reserved(id: T::NftCollectionId) -> bool {
        id <= T::ReserveCollectionIdUpTo::get()
    }
}