I replaced the tight coupling for the timestamp pallet, with a loosely coupling instead.

Author: didiermis

pallets/gated-marketplace/src/functions.rs

@@ -4,6 +4,7 @@ use frame_support::{pallet_prelude::*};
 use frame_support::sp_io::hashing::blake2_256;
 use sp_runtime::sp_std::vec::Vec;
 use crate::types::*;
+use frame_support::traits::Time;
 //use frame_support::traits::{Currency};
 //use frame_support::traits::ExistenceRequirement::KeepAlive;
 
@@ -712,26 +713,13 @@ impl<T: Config> Pallet<T> {
         }
         Ok(())
     }
-    
-    //TODO: merge the timestamp function to convert from moment to milliseconds.
-    fn convert_moment_to_u64_in_milliseconds(date: T::Moment) -> Result<u64, DispatchError> {
-        let date_as_u64_millis;
-        if let Some(_date_as_u64) = TryInto::<u64>::try_into(date).ok() {
-            date_as_u64_millis = _date_as_u64;
-        } else {
-            return Err(Error::<T>::TimestampError)?;
-        }
-        
-        Ok(date_as_u64_millis)
-    }
+
 
     fn get_timestamp_in_milliseconds() -> Option<(u64, u64)> {
-        let timestamp: <T as pallet_timestamp::Config>::Moment = <pallet_timestamp::Pallet<T>>::get();
-        
-        let timestamp2 = Self::convert_moment_to_u64_in_milliseconds(timestamp).unwrap_or(0);
-        let timestamp3 = timestamp2 + (7 * 24 * 60 * 60 * 1000);
+        let timestamp:u64 = T::Timestamp::now().into();
+        let timestamp2 = timestamp + (7 * 24 * 60 * 60 * 1000);
 
-        Some((timestamp2, timestamp3))
+        Some((timestamp, timestamp2))
     }
 
     fn _is_offer_status(offer_id: [u8;32], offer_status: OfferStatus,) -> bool{
@@ -743,14 +731,6 @@ impl<T: Config> Pallet<T> {
         }
     }
 
-    // fn _get_offer_price(offer_id: [u8;32],) -> Result<BalanceOf<T>, DispatchError> {
-    //     //we already know that the offer exists, so we don't need to check it here.
-    //     if let Some(offer) = <OffersInfo<T>>::get(offer_id) {
-    //         return Ok(offer.price);
-    //     } else {
-    //         return Err(Error::<T>::OfferNotFound)?;
-    //     }
-    // }
 
     fn does_exist_offer_id_for_this_item(collection_id: T::CollectionId, item_id: T::ItemId, offer_id: [u8;32]) -> DispatchResult {
         let offers =  <OffersByItem<T>>::try_get(collection_id, item_id).map_err(|_| Error::<T>::OfferNotFound)?;
@@ -759,14 +739,6 @@ impl<T: Config> Pallet<T> {
         Ok(())
     }
 
-    // fn is_the_price_valid(price: BalanceOf<T>,) -> DispatchResult {
-    //     let minimun_amount: BalanceOf<T> = 1000u32.into();
-    //     if price > minimun_amount {
-    //         return Ok(());
-    //     } else {
-    //         return Err(Error::<T>::PriceMustBeGreaterThanZero)?;
-    //     }
-    // }
 
     fn _get_offer_creator(offer_id: [u8;32],) -> Result<T::AccountId, DispatchError> {
         //we already know that the offer exists, so we don't need to check it here.

pallets/gated-marketplace/src/lib.rs

@@ -18,19 +18,32 @@ mod types;
 
 #[frame_support::pallet]
 pub mod pallet {
-	use frame_support::{pallet_prelude::{*, OptionQuery}, transactional};
+	use frame_support::pallet_prelude::*;
+	use frame_support::transactional;
 	use frame_system::pallet_prelude::*;
+	use sp_runtime::traits::Scale;
+	use frame_support::traits::Time;
 	//use frame_support::traits::Currency;
-	//use sp_runtime::sp_std::vec::Vec;
+
+
 	use crate::types::*;
-	//use frame_support::traits::tokens::Balance;
-	//use std::fmt::Debug;
 
 	#[pallet::config]
-	pub trait Config: frame_system::Config + pallet_fruniques::Config + pallet_uniques::Config + pallet_timestamp::Config{
+	pub trait Config: frame_system::Config + pallet_fruniques::Config + pallet_uniques::Config{
 		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
+
 		//type LocalCurrency: Currency<Self::AccountId>;
-		//type Balance: Balance + MaybeSerializeDeserialize + Debug + MaxEncodedLen;
+
+		type Moment: Parameter
+			+ Default
+			+ Scale<Self::BlockNumber, Output = Self::Moment>
+			+ Copy
+			+ MaxEncodedLen
+			+ scale_info::StaticTypeInfo
+			+ Into<u64>;
+			
+		type Timestamp: Time<Moment = Self::Moment>;
+
 
 		type RemoveOrigin: EnsureOrigin<Self::Origin>;		
 		#[pallet::constant]

pallets/gated-marketplace/src/mock.rs

@@ -70,7 +70,6 @@ parameter_types! {
 	pub const MaxFiles: u32 = 10;
 	pub const MaxApplicationsPerCustodian: u32 = 2;
 	pub const MaxMarketsPerItem: u32 = 10;
-
 	pub const MaxOffersPerMarket: u32 = 100;
 }
 
@@ -88,6 +87,8 @@ impl pallet_gated_marketplace::Config for Test {
 	type MaxApplicationsPerCustodian = MaxApplicationsPerCustodian;
 	type MaxOffersPerMarket = MaxOffersPerMarket;
 	type MaxMarketsPerItem = MaxMarketsPerItem;
+	type Timestamp = Timestamp;
+	type Moment = u64;
 	//type LocalCurrency = Balances;
 }
 

runtime/src/lib.rs

@@ -68,6 +68,8 @@ pub type Index = u32;
 /// A hash of some data used by the chain.
 pub type Hash = sp_core::H256;
 
+pub type Moment = u64;	
+
 /// Opaque types. These are used by the CLI to instantiate machinery that don't need to know
 /// the specifics of the runtime. They can then be made to be agnostic over specific formats
 /// of data like extrinsics, allowing for them to continue syncing the network through upgrades
@@ -572,7 +574,9 @@ impl pallet_gated_marketplace::Config for Runtime {
 	type MaxApplicationsPerCustodian = MaxApplicationsPerCustodian;
 	type MaxMarketsPerItem = MaxMarketsPerItem;
 	type MaxOffersPerMarket = MaxOffersPerMarket;
-	//type LocalCurrency = Balances;
+	type Timestamp = Timestamp;
+	type Moment = Moment; 
+
 }
 
 parameter_types! {