diff --git a/Cargo.lock b/Cargo.lock
index d6f149ab..4b7edf8c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3338,6 +3338,7 @@ dependencies = [
"pallet-im-online",
"pallet-indices",
"pallet-lottery",
+ "pallet-mapped-assets",
"pallet-membership",
"pallet-multisig",
"pallet-preimage",
@@ -5989,6 +5990,7 @@ dependencies = [
"log",
"pallet-balances",
"pallet-fruniques",
+ "pallet-mapped-assets",
"pallet-rbac",
"pallet-timestamp",
"pallet-uniques",
diff --git a/pallets/afloat/fruniquesImplementation.drawio b/pallets/afloat/fruniquesImplementation.drawio
new file mode 100644
index 00000000..56263978
--- /dev/null
+++ b/pallets/afloat/fruniquesImplementation.drawio
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/pallets/afloat/src/functions.rs b/pallets/afloat/src/functions.rs
index bb51d0a9..3574f740 100644
--- a/pallets/afloat/src/functions.rs
+++ b/pallets/afloat/src/functions.rs
@@ -4,47 +4,45 @@ use crate::types::*;
use frame_support::traits::UnixTime;
use frame_system::pallet_prelude::*;
use pallet_gated_marketplace::types::MarketplaceRole;
-use pallet_fruniques::types::CollectionDescription;
-use pallet_fruniques::types::FruniqueRole;
+use pallet_fruniques::types::{CollectionDescription, FruniqueRole, Attributes, ParentInfo};
use frame_support::pallet_prelude::*;
// use frame_support::traits::OriginTrait;
+use pallet_rbac::types::IdOrVec;
+use pallet_rbac::types::RoleBasedAccessControl;
+use pallet_rbac::types::RoleId;
+use scale_info::prelude::vec;
+use frame_support::sp_io::hashing::blake2_256;
+use sp_runtime::sp_std::str;
+use sp_runtime::sp_std::vec::Vec;
+use sp_runtime::traits::StaticLookup;
impl Pallet {
pub fn do_initial_setup(creator: T::AccountId, admin: T::AccountId) -> DispatchResult {
+
+ Self::initialize_rbac()?;
+
let creator_user: User = User {
- first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
- last_name: ShortString::try_from(b"Creator".to_vec()).unwrap(),
- email: LongString::try_from(b"".to_vec()).unwrap(),
- lang_key: ShortString::try_from(b"en".to_vec()).unwrap(),
+ cid: ShortString::try_from(b"5HeWymtD558YYKHaZvipqysBHR6PCWgvy96Hg2oah2x7CEH5".to_vec()).unwrap(),
+ group: ShortString::try_from(b"HCD:QmZcSrTcqBdHck73xYw2WHgEQ9tchPrwNq6hM3a3rvXAAV".to_vec()).unwrap(),
created_by: Some(creator.clone()),
created_date: Some(T::TimeProvider::now().as_secs()),
last_modified_by: Some(creator.clone()),
last_modified_date: Some(T::TimeProvider::now().as_secs()),
- phone: None,
- credits_needed: 0,
- cpa_id: ShortString::try_from(b"0".to_vec()).unwrap(),
- tax_authority_id: 1,
- lock_expiration_date: None,
};
>::insert(creator.clone(), creator_user);
+ Self::give_role_to_user(creator.clone(), AfloatRole::Owner)?;
if admin != creator {
let admin_user: User = User {
- first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
- last_name: ShortString::try_from(b"Admin".to_vec()).unwrap(),
- email: LongString::try_from(b"".to_vec()).unwrap(),
- lang_key: ShortString::try_from(b"en".to_vec()).unwrap(),
+ cid: ShortString::try_from(b"5E7RDXG1e98KFsY6qtjRsdnArSMPyRe8fYH9BWPLeLtFMA2w".to_vec()).unwrap(),
+ group: ShortString::try_from(b"HCD:QmbhAm22mGMVrTmAfkjUzbtZrSXVSLV28Xah5ca5NtwQ3U".to_vec()).unwrap(),
created_by: Some(admin.clone()),
created_date: Some(T::TimeProvider::now().as_secs()),
last_modified_by: Some(admin.clone()),
last_modified_date: Some(T::TimeProvider::now().as_secs()),
- phone: None,
- credits_needed: 0,
- cpa_id: ShortString::try_from(b"0".to_vec()).unwrap(),
- tax_authority_id: 1,
- lock_expiration_date: None,
};
- >::insert(admin, admin_user);
+ >::insert(admin.clone(), admin_user);
+ Self::give_role_to_user(admin, AfloatRole::Admin)?;
}
Ok(())
@@ -78,42 +76,30 @@ impl Pallet {
) -> DispatchResult {
ensure!(!>::contains_key(user_address.clone()), Error::::UserAlreadyExists);
match args {
- SignUpArgs::BuyerOrSeller { first_name, last_name, email, state } => {
+ SignUpArgs::BuyerOrSeller { cid, group } => {
let user: User = User {
- first_name,
- last_name,
- email,
- lang_key: ShortString::try_from(b"en".to_vec()).unwrap(),
+ cid: cid,
+ group: group,
created_by: Some(actor.clone()),
created_date: Some(T::TimeProvider::now().as_secs()),
last_modified_by: Some(actor.clone()),
last_modified_date: Some(T::TimeProvider::now().as_secs()),
- phone: None,
- credits_needed: 0,
- cpa_id: ShortString::try_from(b"0".to_vec()).unwrap(),
- tax_authority_id: state,
- lock_expiration_date: None,
};
>::insert(user_address.clone(), user);
+ Self::give_role_to_user(user_address.clone(), AfloatRole::BuyerOrSeller)?;
Self::deposit_event(Event::NewUser(user_address.clone()));
},
- SignUpArgs::CPA { first_name, last_name, email, license_number, state } => {
+ SignUpArgs::CPA { cid, group } => {
let user: User = User {
- first_name,
- last_name,
- email,
- lang_key: ShortString::try_from(b"en".to_vec()).unwrap(),
- created_by: Some(user_address.clone()),
+ cid: cid,
+ group: group,
+ created_by: Some(actor.clone()),
created_date: Some(T::TimeProvider::now().as_secs()),
- last_modified_by: Some(user_address.clone()),
+ last_modified_by: Some(actor.clone()),
last_modified_date: Some(T::TimeProvider::now().as_secs()),
- phone: None,
- credits_needed: 0,
- cpa_id: license_number,
- tax_authority_id: state,
- lock_expiration_date: None,
};
>::insert(user_address.clone(), user);
+ Self::give_role_to_user(user_address.clone(), AfloatRole::CPA)?;
Self::deposit_event(Event::NewUser(user_address.clone()));
},
}
@@ -122,6 +108,7 @@ impl Pallet {
Self::add_to_afloat_collection(user_address.clone(),FruniqueRole::Collaborator)?;
pallet_gated_marketplace::Pallet::::self_enroll(user_address, marketplace_id)?;
+
Ok(())
}
/// Function for editing user information.
@@ -148,52 +135,42 @@ impl Pallet {
pub fn do_edit_user(
actor: T::AccountId,
user_address: T::AccountId,
- first_name: Option,
- last_name: Option,
- email: Option,
- lang_key: Option,
- phone: Option>,
- credits_needed: Option,
- cpa_id: Option,
- state: Option,
+ cid: ShortString,
) -> DispatchResult {
- ensure!(>::contains_key(user_address.clone()), Error::::UserNotFound);
>::try_mutate::<_, _, DispatchError, _>(user_address.clone(), |user| {
let user = user.as_mut().ok_or(Error::::FailedToEditUserAccount)?;
user.last_modified_date = Some(T::TimeProvider::now().as_secs());
user.last_modified_by = Some(actor.clone());
+ user.cid = cid;
- if let Some(first_name) = first_name {
- user.first_name = first_name;
- }
- if let Some(last_name) = last_name {
- user.last_name = last_name;
- }
- if let Some(email) = email {
- user.email = email;
- }
- if let Some(lang_key) = lang_key {
- user.lang_key = lang_key;
- }
- if let Some(phone) = phone {
- user.phone = phone;
- }
- if let Some(credits_needed) = credits_needed {
- user.credits_needed = credits_needed;
- }
- if let Some(cpa_id) = cpa_id {
- user.cpa_id = cpa_id;
- }
- if let Some(state) = state {
- user.tax_authority_id = state;
- }
+ Ok(())
+ })?;
+
+ Ok(())
+ }
+
+ pub fn do_admin_edit_user(
+ actor: T::AccountId,
+ user_address: T::AccountId,
+ cid: ShortString,
+ group: ShortString
+ ) -> DispatchResult {
+
+ >::try_mutate::<_, _, DispatchError, _>(user_address.clone(), |user| {
+ let user = user.as_mut().ok_or(Error::::FailedToEditUserAccount)?;
+
+ user.last_modified_date = Some(T::TimeProvider::now().as_secs());
+ user.last_modified_by = Some(actor.clone());
+ user.cid = cid;
+ user.group = group;
Ok(())
})?;
Ok(())
+
}
/// Function for deleting a user account.
///
@@ -209,19 +186,213 @@ impl Pallet {
/// Returns Ok(()) on success.
///
pub fn do_delete_user(_actor: T::AccountId, user_address: T::AccountId) -> DispatchResult {
- ensure!(>::contains_key(user_address.clone()), Error::::UserNotFound);
-
+
Self::remove_from_afloat_collection(user_address.clone(), FruniqueRole::Collaborator)?;
Self::remove_from_afloat_marketplace(user_address.clone())?;
+ let user_roles = Self::get_all_roles_for_user(user_address.clone());
+
+ if !user_roles.is_empty() {
+ for role in user_roles {
+ Self::remove_role_from_user(user_address.clone(), role)?;
+ }
+ }
>::remove(user_address.clone());
Self::deposit_event(Event::UserDeleted(user_address.clone()));
Ok(())
}
+ pub fn do_set_afloat_balance(
+ origin: OriginFor,
+ user_address: T::AccountId,
+ amount: T::Balance,
+ ) -> DispatchResult {
+
+ let authority = ensure_signed(origin.clone())?;
+ let asset_id = AfloatAssetId::::get().expect("AfloatAssetId should be set");
+
+ ensure!(UserInfo::::contains_key(user_address.clone()), Error::::UserNotFound);
+
+ let current_balance = Self::do_get_afloat_balance(user_address.clone());
+
+ if current_balance > amount {
+ let diff = current_balance - amount;
+ pallet_mapped_assets::Pallet::::burn(
+ origin.clone(),
+ asset_id.into(),
+ T::Lookup::unlookup(user_address.clone()),
+ diff,
+ )?;
+ } else if current_balance < amount {
+ let diff = amount - current_balance;
+ pallet_mapped_assets::Pallet::::mint(
+ origin.clone(),
+ asset_id.into(),
+ T::Lookup::unlookup(user_address.clone()),
+ diff,
+ )?;
+ }
+
+ Self::deposit_event(Event::AfloatBalanceSet(authority, user_address, amount));
+ Ok(())
+ }
+
+ pub fn do_get_afloat_balance(user_address: T::AccountId) -> T::Balance {
+ let asset_id = AfloatAssetId::::get().expect("AfloatAssetId should be set");
+ pallet_mapped_assets::Pallet::::balance(asset_id.into(), user_address)
+ }
+
+
+ pub fn do_create_sell_order(
+ authority: T::AccountId,
+ item_id: ::ItemId,
+ price: T::Balance,
+ tax_credit_amount: u32,
+ expiration_date: Date,
+ ) -> DispatchResult
+ {
+
+ ensure!(!Self::get_all_roles_for_user(authority.clone()).is_empty(), Error::::Unauthorized);
+
+ let marketplace_id = AfloatMarketPlaceId::::get().unwrap();
+ let collection_id = AfloatCollectionId::::get().unwrap();
+
+ let offer_id = pallet_gated_marketplace::Pallet::::do_enlist_sell_offer(
+ authority.clone(),
+ marketplace_id,
+ collection_id,
+ item_id,
+ price,
+ tax_credit_amount,
+ )?;
+
+ let offer: Offer = Offer {
+ tax_credit_amount,
+ tax_credit_amount_remaining: tax_credit_amount,
+ price_per_credit: price,
+ creation_date: T::TimeProvider::now().as_secs(),
+ expiration_date: expiration_date,
+ tax_credit_id: item_id,
+ creator_id: authority.clone(),
+ status: OfferStatus::default(),
+ offer_type: OfferType::Sell,
+ cancellation_date: None,
+ };
+
+ >::insert(offer_id, offer);
+
+
+ Self::deposit_event(Event::SellOrderCreated(authority));
+
+ Ok(())
+ }
+
+ pub fn do_create_buy_order(
+ authority: T::AccountId,
+ item_id: ::ItemId,
+ price: T::Balance,
+ tax_credit_amount: u32,
+ expiration_date: Date,
+ ) -> DispatchResult
+ {
+ ensure!(!Self::get_all_roles_for_user(authority.clone()).is_empty(), Error::::Unauthorized);
+
+ let marketplace_id = AfloatMarketPlaceId::::get().unwrap();
+ let collection_id = AfloatCollectionId::::get().unwrap();
+
+ let offer_id = pallet_gated_marketplace::Pallet::::do_enlist_buy_offer(
+ authority.clone(),
+ marketplace_id,
+ collection_id,
+ item_id,
+ price,
+ tax_credit_amount,
+ )?;
+
+ let offer: Offer = Offer {
+ tax_credit_amount,
+ tax_credit_amount_remaining: tax_credit_amount,
+ price_per_credit: price,
+ creation_date: T::TimeProvider::now().as_secs(),
+ expiration_date: expiration_date,
+ tax_credit_id: item_id,
+ creator_id: authority.clone(),
+ status: OfferStatus::default(),
+ offer_type: OfferType::Buy,
+ cancellation_date: None,
+ };
+
+ >::insert(offer_id, offer);
+
+ Self::deposit_event(Event::BuyOrderCreated(authority));
+
+ Ok(())
+ }
+
+ pub fn do_take_sell_order(
+ authority: OriginFor,
+ order_id: [u8; 32],
+ ) -> DispatchResult
+ where
+ ::ItemId: From
+ {
+ let who = ensure_signed(authority.clone())?;
+
+ ensure!(!Self::get_all_roles_for_user(who.clone()).is_empty(), Error::::Unauthorized);
+
+ pallet_gated_marketplace::Pallet::::do_take_sell_offer(
+ authority.clone(),
+ order_id,
+ )?;
+
+ Self::deposit_event(Event::SellOrderTaken(who));
+ Ok(())
+ }
+
+ pub fn do_take_buy_order(
+ authority: T::AccountId,
+ order_id: [u8; 32],
+ ) -> DispatchResult
+ where
+ ::ItemId: From
+ {
+ ensure!(!Self::get_all_roles_for_user(authority.clone()).is_empty(), Error::::Unauthorized);
+
+ pallet_gated_marketplace::Pallet::::do_take_buy_offer(
+ authority.clone(),
+ order_id,
+ )?;
+
+ Self::deposit_event(Event::BuyOrderTaken(authority));
+ Ok(())
+ }
+
+ pub fn do_create_tax_credit(
+ owner: T::AccountId,
+ metadata: CollectionDescription,
+ attributes: Option>,
+ parent_info: Option>,
+ ) -> DispatchResult
+ where
+ ::ItemId: From,
+ ::CollectionId: From,
+ {
+ ensure!(!Self::get_all_roles_for_user(owner.clone()).is_empty(), Error::::Unauthorized);
+
+ let collection = AfloatCollectionId::::get().unwrap();
+
+ pallet_fruniques::Pallet::::do_spawn(
+ collection,
+ owner,
+ metadata,
+ attributes,
+ parent_info,
+ )
+ }
+
pub fn create_afloat_collection(origin: OriginFor,
metadata: CollectionDescription,
- admin: T::AccountId, ) -> DispatchResult
+ admin: T::AccountId, ) -> DispatchResult
where
::CollectionId: From,
{
@@ -259,4 +430,142 @@ impl Pallet {
let marketplace_id = AfloatMarketPlaceId::::get().unwrap();
pallet_gated_marketplace::Pallet::::remove_from_market_lists(invitee, MarketplaceRole::Participant, marketplace_id)
}
+
+ pub fn pallet_id() -> IdOrVec {
+ IdOrVec::Vec(Self::module_name().as_bytes().to_vec())
+ }
+
+ pub fn is_admin_or_owner(account: T::AccountId) -> bool {
+ let marketplace_id = AfloatMarketPlaceId::::get().unwrap();
+ ::Rbac::has_role(
+ account.clone(),
+ Self::pallet_id(),
+ &marketplace_id,
+ [AfloatRole::Admin.id(), AfloatRole::Owner.id()].to_vec(),
+ )
+ .is_ok()
+ }
+
+ pub fn is_owner(account: T::AccountId) -> bool {
+ let marketplace_id = AfloatMarketPlaceId::::get().unwrap();
+ ::Rbac::has_role(
+ account.clone(),
+ Self::pallet_id(),
+ &marketplace_id,
+ [AfloatRole::Owner.id()].to_vec(),
+ )
+ .is_ok()
+ }
+
+ pub fn is_cpa(account: T::AccountId) -> bool {
+ let marketplace_id = AfloatMarketPlaceId::::get().unwrap();
+ ::Rbac::has_role(
+ account.clone(),
+ Self::pallet_id(),
+ &marketplace_id,
+ [AfloatRole::CPA.id()].to_vec(),
+ )
+ .is_ok()
+ }
+
+ pub fn give_role_to_user(
+ authority: T::AccountId,
+ role: AfloatRole,
+ ) -> DispatchResult {
+ let marketplace_id = AfloatMarketPlaceId::::get().unwrap();
+ ::Rbac::assign_role_to_user(
+ authority,
+ Self::pallet_id(),
+ &marketplace_id,
+ role.id(),
+ )?;
+
+ Ok(())
+ }
+
+ pub fn remove_role_from_user(
+ authority: T::AccountId,
+ role: AfloatRole,
+ ) -> DispatchResult {
+ let marketplace_id = AfloatMarketPlaceId::::get().unwrap();
+ ::Rbac::remove_role_from_user(
+ authority,
+ Self::pallet_id(),
+ &marketplace_id,
+ role.id(),
+ )?;
+
+ Ok(())
+ }
+
+ pub fn initialize_rbac() -> DispatchResult {
+ let marketplace_id = AfloatMarketPlaceId::::get().unwrap();
+ ::Rbac::create_scope(Self::pallet_id(), marketplace_id)?;
+ let pallet_id = Self::pallet_id();
+ let super_roles = vec![AfloatRole::Owner.to_vec(), AfloatRole::Admin.to_vec()];
+ let super_role_ids =
+ ::Rbac::create_and_set_roles(pallet_id.clone(), super_roles)?;
+ let super_permissions = Permission::admin_permissions();
+ for super_role in super_role_ids {
+ ::Rbac::create_and_set_permissions(
+ pallet_id.clone(),
+ super_role,
+ super_permissions.clone(),
+ )?;
+ }
+ let participant_roles = vec![AfloatRole::BuyerOrSeller.to_vec(), AfloatRole::CPA.to_vec()];
+ ::Rbac::create_and_set_roles(
+ pallet_id.clone(),
+ participant_roles,
+ )?;
+
+ Ok(())
+ }
+
+ fn role_id_to_afloat_role(role_id: RoleId) -> Option {
+ AfloatRole::enum_to_vec()
+ .iter()
+ .find(|role_bytes| role_bytes.using_encoded(blake2_256) == role_id)
+ .map(|role_bytes| {
+ let role_str = str::from_utf8(role_bytes).expect("Role bytes should be valid UTF-8");
+
+ match role_str {
+ "Owner" => AfloatRole::Owner,
+ "Admin" => AfloatRole::Admin,
+ "BuyerOrSeller" => AfloatRole::BuyerOrSeller,
+ "CPA" => AfloatRole::CPA,
+ _ => panic!("Unexpected role string"),
+ }
+ })
+ }
+
+ fn get_all_roles_for_user(account_id: T::AccountId) -> Vec {
+ let pallet_id = Self::pallet_id();
+ let scope_id = AfloatMarketPlaceId::::get().unwrap();
+
+ let roles_storage = ::Rbac::get_roles_by_user(account_id.clone(), pallet_id, &scope_id);
+
+ roles_storage.into_iter().filter_map(Self::role_id_to_afloat_role).collect()
+ }
+
+ pub fn do_delete_all_users() -> DispatchResult {
+ UserInfo::::iter_keys().try_for_each(|account_id| {
+ if !Self::is_admin_or_owner(account_id.clone()) {
+ let user_roles = Self::get_all_roles_for_user(account_id.clone());
+
+ if !user_roles.is_empty() {
+ for role in user_roles {
+ Self::remove_role_from_user(account_id.clone(), role)?;
+ }
+ }
+
+ Self::remove_from_afloat_collection(account_id.clone(), FruniqueRole::Collaborator)?;
+ Self::remove_from_afloat_marketplace(account_id.clone())?;
+ UserInfo::::remove(account_id);
+ }
+ Ok::<(), DispatchError>(())
+ })?;
+ Ok(())
+ }
+
}
diff --git a/pallets/afloat/src/lib.rs b/pallets/afloat/src/lib.rs
index c5d1bc22..629a46b2 100644
--- a/pallets/afloat/src/lib.rs
+++ b/pallets/afloat/src/lib.rs
@@ -21,9 +21,7 @@ pub mod pallet {
use frame_system::RawOrigin;
use pallet_gated_marketplace::types::*;
use sp_runtime::Permill;
- use sp_runtime::traits::StaticLookup;
- use pallet_fruniques::types::CollectionDescription;
- use pallet_fruniques::types::FruniqueRole;
+ use pallet_fruniques::types::{CollectionDescription, FruniqueRole, Attributes, ParentInfo};
const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
use crate::types::*;
@@ -41,6 +39,7 @@ pub mod pallet {
type Rbac: RoleBasedAccessControl;
type RemoveOrigin: EnsureOrigin;
type Currency: Currency;
+ type ItemId: Parameter + Member + Default;
}
#[pallet::pallet]
@@ -57,6 +56,11 @@ pub mod pallet {
NewUser(T::AccountId),
UserEdited(T::AccountId),
UserDeleted(T::AccountId),
+ SellOrderCreated(T::AccountId),
+ BuyOrderCreated(T::AccountId),
+ SellOrderTaken(T::AccountId),
+ BuyOrderTaken(T::AccountId),
+ AfloatBalanceSet(T::AccountId, T::AccountId, T::Balance),
}
// Errors inform users that something went wrong.
@@ -76,6 +80,14 @@ pub mod pallet {
FailedToEditUserAccount,
// Failed to create fruniques collection
FailedToCreateFruniquesCollection,
+ // Failed to remove Fruniques role
+ FailedToRemoveFruniquesRole,
+ // User is not authorized to perform this action
+ Unauthorized,
+ // Pallet has not ben initialized yet
+ NotInitialized,
+ // Failed to remove afloat role
+ FailedToRemoveAfloatRole,
}
#[pallet::storage]
@@ -103,10 +115,38 @@ pub mod pallet {
::CollectionId, // Afloat's frunique collection id
>;
+ #[pallet::storage]
+ #[pallet::getter(fn asset_id)]
+ pub(super) type AfloatAssetId = StorageValue<
+ _,
+ ::AssetId, // Afloat's frunique collection id
+ >;
+
+ #[pallet::storage]
+ #[pallet::getter(fn afloat_offers)]
+ pub(super) type AfloatOffers = StorageMap<
+ _,
+ Blake2_128Concat,
+ StorageId,
+ Offer,
+ OptionQuery,
+ >;
+
+ #[pallet::storage]
+ #[pallet::getter(fn afloat_transactions)]
+ pub(super) type AfloatTransactions = StorageMap<
+ _,
+ Blake2_128Concat,
+ StorageId,
+ Transaction,
+ OptionQuery,
+ >;
+
#[pallet::call]
- impl Pallet
+ impl Pallet
where
- T: pallet_uniques::Config
+ T: pallet_uniques::Config,
+ ::ItemId: From
{
#[pallet::call_index(0)]
#[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(1,1))]
@@ -119,46 +159,42 @@ pub mod pallet {
{
ensure_signed(origin.clone())?;
let asset_id: T::AssetId = Default::default();
- let min_balance: T::Balance = T::Balance::from(1u32);
- let metadata: CollectionDescription = BoundedVec::try_from(b"Afloat".to_vec()).expect("Label too long");
+ AfloatAssetId::::put(asset_id.clone());
- pallet_mapped_assets::Pallet::::create(
- origin.clone(),
- asset_id,
- T::Lookup::unlookup(creator.clone()),
- min_balance,
- )?;
+ let metadata: CollectionDescription = BoundedVec::try_from(b"Afloat".to_vec()).expect("Label too long");
pallet_fruniques::Pallet::::do_initial_setup()?;
-
+
Self::create_afloat_collection(RawOrigin::Signed(creator.clone()).into(), metadata, admin.clone())?;
pallet_gated_marketplace::Pallet::::do_initial_setup()?;
- Self::do_initial_setup(creator.clone(), admin.clone())?;
-
let label: BoundedVec =
BoundedVec::try_from(b"Afloat".to_vec()).expect("Label too long");
let marketplace: Marketplace = Marketplace {
label,
buy_fee: Permill::from_percent(2),
sell_fee: Permill::from_percent(4),
+ asset_id,
creator: creator.clone(),
};
let marketplace_id = marketplace.clone().using_encoded(blake2_256);
AfloatMarketPlaceId::::put(marketplace_id);
Self::add_to_afloat_collection(admin.clone(),FruniqueRole::Admin)?;
- pallet_gated_marketplace::Pallet::do_create_marketplace(creator, admin, marketplace)?;
+ pallet_gated_marketplace::Pallet::do_create_marketplace(RawOrigin::Signed(creator.clone()).into(), admin.clone(), marketplace)?;
+
+ Self::do_initial_setup(creator, admin)?;
+
Ok(())
}
#[pallet::call_index(1)]
#[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(1,1))]
pub fn kill_storage(origin: OriginFor) -> DispatchResult {
- ensure_signed(origin.clone())?;
- >::kill();
- let _ = >::clear(1000, None);
+ let who = ensure_signed(origin.clone())?;
+ ensure!(Self::is_admin_or_owner(who), Error::::Unauthorized);
+ Self::do_delete_all_users()?;
Ok(())
}
@@ -176,19 +212,119 @@ pub mod pallet {
address: T::AccountId,
args: UpdateUserArgs,
) -> DispatchResult {
- // TODO: Check if the user is editing himself or is an admin
+
let who = ensure_signed(origin)?;
+ ensure!(>::contains_key(address.clone()), Error::::UserNotFound);
+ ensure!(who.clone() == address || Self::is_admin_or_owner(who.clone()), Error::::Unauthorized);
+
match args {
- UpdateUserArgs::Edit { first_name, last_name, email, lang_key, phone, credits_needed, cpa_id, state } => {
- Self::do_edit_user(who, address, first_name, last_name, email, lang_key, phone, credits_needed, cpa_id, state)?;
+ UpdateUserArgs::Edit { cid } => {
+ Self::do_edit_user(who, address, cid)?;
+ }
+ UpdateUserArgs::AdminEdit { cid, group } => {
+ ensure!(Self::is_admin_or_owner(who.clone()), Error::::Unauthorized);
+ Self::do_admin_edit_user(who, address, cid, group)?;
}
UpdateUserArgs::Delete => {
+ ensure!(Self::is_admin_or_owner(who.clone()), Error::::Unauthorized);
Self::do_delete_user(who, address)?;
}
}
Ok(())
}
+
+ #[pallet::call_index(4)]
+ #[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(1,1))]
+ pub fn create_offer(
+ origin: OriginFor,
+ args: CreateOfferArgs,
+ )
+ -> DispatchResult
+ {
+ let who = ensure_signed(origin)?;
+ match args {
+ CreateOfferArgs::Sell { tax_credit_amount, tax_credit_id, price_per_credit, expiration_date } => {
+ Self::do_create_sell_order(who, tax_credit_id, price_per_credit, tax_credit_amount, expiration_date)?;
+ }
+ CreateOfferArgs::Buy { tax_credit_amount, tax_credit_id, price_per_credit, expiration_date } => {
+ Self::do_create_buy_order(who, tax_credit_id, price_per_credit, tax_credit_amount, expiration_date)?;
+ }
+ }
+ Ok(())
+ }
+
+ #[pallet::call_index(5)]
+ #[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(1,1))]
+ pub fn accept_offer(
+ origin: OriginFor,
+ offer_id: [u8; 32],
+ amount: Option,
+ )
+ -> DispatchResult
+ {
+ ensure_signed(origin.clone())?;
+ Ok(())
+ }
+
+
+
+
+ #[pallet::call_index(6)]
+ #[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(1,1))]
+ pub fn take_sell_order(
+ origin: OriginFor,
+ offer_id: [u8; 32],
+ )
+ -> DispatchResult
+ {
+ ensure_signed(origin.clone())?;
+ Self::do_take_sell_order(origin , offer_id)
+ }
+
+ #[pallet::call_index(7)]
+ #[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(1,1))]
+ pub fn take_buy_order(
+ origin: OriginFor,
+ offer_id: [u8; 32],
+ )
+ -> DispatchResult
+ {
+ let who = ensure_signed(origin)?;
+ Self::do_take_buy_order(who , offer_id)
+ }
+
+ #[pallet::call_index(8)]
+ #[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(2,1))]
+ pub fn create_tax_credit(
+ origin: OriginFor,
+ metadata: CollectionDescription,
+ attributes: Option>,
+ parent_info: Option>,
+ )
+ -> DispatchResult
+ {
+ let who = ensure_signed(origin)?;
+ Self::do_create_tax_credit(who , metadata, attributes, parent_info)
+ }
+
+ #[pallet::call_index(9)]
+ #[pallet::weight(Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(2,1))]
+ pub fn set_afloat_balance(
+ origin: OriginFor,
+ beneficiary: T::AccountId,
+ amount: T::Balance,
+ )
+ -> DispatchResult
+ {
+ ensure_signed(origin.clone())?;
+
+ // Only the owner can set afloat balance
+ ensure!(Self::is_owner(ensure_signed(origin.clone())?), Error::::Unauthorized);
+
+ Self::do_set_afloat_balance(origin, beneficiary, amount)
+ }
+
}
}
diff --git a/pallets/afloat/src/mock.rs b/pallets/afloat/src/mock.rs
index ffb891d7..92583526 100644
--- a/pallets/afloat/src/mock.rs
+++ b/pallets/afloat/src/mock.rs
@@ -1,17 +1,28 @@
use crate as pallet_afloat;
-use frame_support::{parameter_types, traits::AsEnsureOriginWithArg};
+use frame_support::{
+ parameter_types,
+ traits::{AsEnsureOriginWithArg, ConstU32, ConstU64, Currency},
+};
use frame_system as system;
use sp_core::H256;
use sp_runtime::{
testing::Header,
traits::{BlakeTwo256, IdentityLookup},
};
-
type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic;
type Block = frame_system::mocking::MockBlock;
use frame_system::EnsureRoot;
use system::EnsureSigned;
+use frame_system::RawOrigin;
+
+type AssetId = u32;
+
+parameter_types! {
+ pub const BlockHashCount: u64 = 250;
+ pub const SS58Prefix: u8 = 42;
+}
+
// Configure a mock runtime to test the pallet.
frame_support::construct_runtime!(
pub enum Test where
@@ -20,21 +31,17 @@ frame_support::construct_runtime!(
UncheckedExtrinsic = UncheckedExtrinsic,
{
System: frame_system::{Pallet, Call, Config, Storage, Event},
- AfloatModule: pallet_afloat::{Pallet, Call, Storage, Event},
GatedMarketplace: pallet_gated_marketplace::{Pallet, Call, Storage, Event},
Uniques: pallet_uniques::{Pallet, Call, Storage, Event},
Fruniques: pallet_fruniques::{Pallet, Call, Storage, Event},
Balances: pallet_balances::{Pallet, Call, Storage, Config, Event},
Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent},
RBAC: pallet_rbac::{Pallet, Call, Storage, Event},
+ Assets: pallet_mapped_assets::{Pallet, Call, Storage, Event},
+ Afloat: pallet_afloat::{Pallet, Call, Storage, Event},
}
);
-parameter_types! {
- pub const BlockHashCount: u64 = 250;
- pub const SS58Prefix: u8 = 42;
-}
-
impl system::Config for Test {
type BaseCallFilter = frame_support::traits::Everything;
type BlockWeights = ();
@@ -53,20 +60,24 @@ impl system::Config for Test {
type BlockHashCount = BlockHashCount;
type Version = ();
type PalletInfo = PalletInfo;
- type AccountData = ();
type OnNewAccount = ();
type OnKilledAccount = ();
type SystemWeightInfo = ();
type SS58Prefix = SS58Prefix;
type OnSetCode = ();
type MaxConsumers = frame_support::traits::ConstU32<16>;
+ type AccountData = pallet_balances::AccountData;
+
}
+
impl pallet_afloat::Config for Test {
type RuntimeEvent = RuntimeEvent;
- type Moment = u64;
- type Timestamp = Timestamp;
- // type Rbac = RBAC;
+ type TimeProvider = pallet_timestamp::Pallet;
+ type RemoveOrigin = frame_system::EnsureSigned;
+ type Currency = pallet_balances::Pallet;
+ type Rbac = RBAC;
+ type ItemId = u32;
}
parameter_types! {
@@ -185,7 +196,65 @@ impl pallet_rbac::Config for Test {
type MaxUsersPerRole = MaxUsersPerRole;
}
+impl pallet_timestamp::Config for Test {
+ type Moment = u64;
+ type OnTimestampSet = ();
+ type MinimumPeriod = ();
+ type WeightInfo = ();
+}
+
+
+
+pub trait AssetsCallback {
+ /// Indicates that asset with `id` was successfully created by the `owner`
+ fn created(_id: &AssetId, _owner: &AccountId) {}
+
+ /// Indicates that asset with `id` has just been destroyed
+ fn destroyed(_id: &AssetId) {}
+}
+
+pub struct AssetsCallbackHandle;
+impl pallet_mapped_assets::AssetsCallback for AssetsCallbackHandle {
+ fn created(_id: &AssetId, _owner: &u64) {
+ }
+
+ fn destroyed(_id: &AssetId) {
+ }
+}
+
+
+impl pallet_mapped_assets::Config for Test {
+ type RuntimeEvent = RuntimeEvent;
+ type Balance = u64;
+ type AssetId = u32;
+ type AssetIdParameter = u32;
+ type Currency = Balances;
+ type CreateOrigin = AsEnsureOriginWithArg>;
+ type ForceOrigin = frame_system::EnsureRoot;
+ type AssetDeposit = ConstU64<1>;
+ type AssetAccountDeposit = ConstU64<10>;
+ type MetadataDepositBase = ConstU64<1>;
+ type MetadataDepositPerByte = ConstU64<1>;
+ type ApprovalDeposit = ConstU64<1>;
+ type StringLimit = ConstU32<50>;
+ type Freezer = ();
+ type WeightInfo = ();
+ type CallbackHandle = AssetsCallbackHandle;
+ type Extra = ();
+ type RemoveItemsLimit = ConstU32<5>;
+ type MaxReserves = MaxReserves;
+ type ReserveIdentifier = u32;
+}
+
// Build genesis storage according to the mock runtime.
pub fn new_test_ext() -> sp_io::TestExternalities {
- system::GenesisConfig::default().build_storage::().unwrap().into()
-}
+ // TODO: get initial conf?
+ let mut t: sp_io::TestExternalities =
+ frame_system::GenesisConfig::default().build_storage::().unwrap().into();
+ t.execute_with(|| {
+ Balances::make_free_balance_be(&1, 100);
+ Balances::make_free_balance_be(&2, 100);
+ Afloat::initial_setup(RawOrigin::Signed(1).into(), 1, 2).expect("Error on GatedMarketplace configuring initial setup");
+ });
+ t
+}
\ No newline at end of file
diff --git a/pallets/afloat/src/tests.rs b/pallets/afloat/src/tests.rs
index bc3b5fc2..ce40dd7e 100644
--- a/pallets/afloat/src/tests.rs
+++ b/pallets/afloat/src/tests.rs
@@ -1,2 +1,512 @@
-use crate::{mock::*, Error};
-use frame_support::{assert_noop, assert_ok};
+use super::*;
+use crate::{mock::*, types::*,Error};
+use frame_system::RawOrigin;
+use frame_support::{
+ assert_noop, assert_ok,
+ traits::Currency,
+ BoundedVec,
+};
+
+fn new_account(account_id: u64) -> ::AccountId {
+ account_id
+}
+
+fn dummy_description() -> BoundedVec {
+ BoundedVec::::try_from(b"dummy description".to_vec()).unwrap()
+}
+
+//owner_id = 1
+//admin_id = 2
+//buy_fee = 2%
+//sell_fee = 4%
+
+#[test]
+fn sign_up_works() {
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ Balances::make_free_balance_be(&user, 100);
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 1,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args));
+
+ assert!(UserInfo::::contains_key(user));
+ });
+}
+
+#[test]
+fn update_user_info_edit_works() {
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ Balances::make_free_balance_be(&user, 100);
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 1,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args));
+
+ let update_args = UpdateUserArgs::Edit {
+ first_name: Some(ShortString::try_from(b"New".to_vec()).unwrap()),
+ last_name: Some(ShortString::try_from(b"User".to_vec()).unwrap()),
+ email: Some(LongString::try_from(b"Info".to_vec()).unwrap()),
+ lang_key: None,
+ phone: None,
+ credits_needed: None,
+ cpa_id: None,
+ state: None,
+ };
+
+ assert_ok!(Afloat::update_user_info(
+ RawOrigin::Signed(user.clone()).into(),
+ user.clone(),
+ update_args
+ ));
+
+ let updated_user = UserInfo::::get(user).unwrap();
+ assert_eq!(updated_user.first_name, ShortString::try_from(b"New".to_vec()).unwrap());
+ assert_eq!(updated_user.last_name, ShortString::try_from(b"User".to_vec()).unwrap());
+ assert_eq!(updated_user.email, LongString::try_from(b"Info".to_vec()).unwrap());
+
+ });
+}
+
+#[test]
+fn update_other_user_info_by_not_admin_fails() {
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ let other_user = new_account(4);
+
+ Balances::make_free_balance_be(&user, 100);
+ Balances::make_free_balance_be(&other_user, 100);
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 1,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args));
+
+ let update_args = UpdateUserArgs::Edit {
+ first_name: Some(ShortString::try_from(b"New".to_vec()).unwrap()),
+ last_name: Some(ShortString::try_from(b"User".to_vec()).unwrap()),
+ email: Some(LongString::try_from(b"Info".to_vec()).unwrap()),
+ lang_key: None,
+ phone: None,
+ credits_needed: None,
+ cpa_id: None,
+ state: None,
+ };
+
+ assert_noop!(
+ Afloat::update_user_info(
+ RawOrigin::Signed(other_user.clone()).into(),
+ user.clone(),
+ update_args
+ ),
+ Error::::Unauthorized
+ );
+ });
+}
+
+#[test]
+fn update_other_user_info_by_admin_works() {
+ new_test_ext().execute_with(|| {
+ let owner = new_account(1);
+ let admin = new_account(2);
+ let user = new_account(3);
+ let other_user = new_account(4);
+
+ Balances::make_free_balance_be(&owner, 100);
+ Balances::make_free_balance_be(&admin, 100);
+ Balances::make_free_balance_be(&user, 100);
+ Balances::make_free_balance_be(&other_user, 100);
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 1,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args));
+
+ let update_args = UpdateUserArgs::Edit {
+ first_name: Some(ShortString::try_from(b"New".to_vec()).unwrap()),
+ last_name: Some(ShortString::try_from(b"User".to_vec()).unwrap()),
+ email: Some(LongString::try_from(b"Info".to_vec()).unwrap()),
+ lang_key: None,
+ phone: None,
+ credits_needed: None,
+ cpa_id: None,
+ state: None,
+ };
+
+ assert_ok!(Afloat::update_user_info(
+ RawOrigin::Signed(admin.clone()).into(),
+ user.clone(),
+ update_args
+ ));
+
+ let updated_user = UserInfo::::get(user).unwrap();
+ assert_eq!(updated_user.first_name, ShortString::try_from(b"New".to_vec()).unwrap());
+ assert_eq!(updated_user.last_name, ShortString::try_from(b"User".to_vec()).unwrap());
+ assert_eq!(updated_user.email, LongString::try_from(b"Info".to_vec()).unwrap());
+ });
+}
+
+#[test]
+fn update_user_info_delete_works() {
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ Balances::make_free_balance_be(&user, 100);
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 1,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args));
+
+ assert_ok!(Afloat::update_user_info(
+ RawOrigin::Signed(user.clone()).into(),
+ user.clone(),
+ UpdateUserArgs::Delete
+ ));
+
+ assert!(!UserInfo::::contains_key(user));
+ });
+}
+
+#[test]
+fn kill_storage_works() {
+ new_test_ext().execute_with(|| {
+ let owner = new_account(1);
+ let admin = new_account(2);
+
+ let user1 = new_account(3);
+ let user2 = new_account(4);
+
+ Balances::make_free_balance_be(&user1, 100);
+ Balances::make_free_balance_be(&user2, 100);
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 1,
+ };
+
+
+
+ // Add users
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user1.clone()).into(), args.clone()));
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user2.clone()).into(), args.clone()));
+
+ // Ensure users exist
+ assert!(UserInfo::::contains_key(user1));
+ assert!(UserInfo::::contains_key(user2));
+
+ // Kill storage with admin
+ assert_ok!(Afloat::kill_storage(RawOrigin::Signed(admin.clone()).into()));
+
+ // Ensure users no longer exist
+ assert!(!UserInfo::::contains_key(user1));
+ assert!(!UserInfo::::contains_key(user2));
+
+ // Ensure admin and owner still exists
+ assert!(UserInfo::::contains_key(admin));
+ assert!(UserInfo::::contains_key(owner));
+
+ // Add users again
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user1.clone()).into(), args.clone()));
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user2.clone()).into(), args.clone()));
+
+ });
+}
+
+#[test]
+fn kill_storage_fails_for_non_admin() {
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+
+ // Attempt to kill storage with non-admin user
+ assert_noop!(
+ Afloat::kill_storage(RawOrigin::Signed(user.clone()).into()),
+ Error::::Unauthorized
+ );
+ });
+}
+
+#[test]
+fn set_afloat_balance_works(){
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ let other_user = new_account(4);
+
+ Balances::make_free_balance_be(&user, 100);
+ Balances::make_free_balance_be(&other_user, 100);
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 1,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args.clone()));
+
+ assert_ok!(Afloat::set_afloat_balance(RawOrigin::Signed(1).into(), user.clone(), 10000));
+ assert_eq!(Afloat::do_get_afloat_balance(user.clone()), 10000);
+ assert_ok!(Afloat::set_afloat_balance(RawOrigin::Signed(1).into(), user.clone(), 1000));
+ assert_eq!(Afloat::do_get_afloat_balance(user.clone()), 1000);
+
+ });
+
+}
+
+#[test]
+fn set_balance_by_other_than_owner_fails(){
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ let other_user = new_account(4);
+
+ Balances::make_free_balance_be(&user, 100);
+ Balances::make_free_balance_be(&other_user, 100);
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 1,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args.clone()));
+
+ assert_noop!(Afloat::set_afloat_balance(RawOrigin::Signed(3).into(), other_user.clone(), 10000), Error::::Unauthorized);
+ assert_noop!(Afloat::set_afloat_balance(RawOrigin::Signed(2).into(), other_user.clone(), 10000), Error::::Unauthorized);
+ });
+
+}
+
+#[test]
+fn create_tax_credit_works() {
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ let other_user = new_account(4);
+
+ Balances::make_free_balance_be(&user, 100);
+ Balances::make_free_balance_be(&other_user, 100);
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 1,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args.clone()));
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(other_user.clone()).into(), args.clone()));
+
+
+ assert_ok!(Afloat::create_tax_credit(
+ RawOrigin::Signed(user.clone()).into(),
+ dummy_description(),
+ None,
+ None,
+ ));
+
+
+ });
+}
+
+#[test]
+fn create_sell_order_works() {
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ let other_user = new_account(4);
+ let item_id = 0;
+
+ Balances::make_free_balance_be(&user, 100);
+ Balances::make_free_balance_be(&other_user, 100);
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 0,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args.clone()));
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(other_user.clone()).into(), args.clone()));
+
+ assert_ok!(Afloat::create_tax_credit(
+ RawOrigin::Signed(3).into(),
+ dummy_description(),
+ None,
+ None,
+ ));
+
+ assert_ok!(Afloat::create_sell_order(
+ RawOrigin::Signed(user.clone()).into(),
+ item_id,
+ 10000,
+ 10,
+ ));
+
+ });
+
+}
+
+#[test]
+fn take_sell_order_works() {
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ let other_user = new_account(4);
+ let item_id = 0;
+
+ Balances::make_free_balance_be(&user, 100);
+ Balances::make_free_balance_be(&other_user, 100);
+
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 0,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args.clone()));
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(other_user.clone()).into(), args.clone()));
+
+ assert_ok!(Afloat::set_afloat_balance(RuntimeOrigin::signed(1), 4, 100000));
+
+ assert_ok!(Afloat::create_tax_credit(
+ RawOrigin::Signed(user.clone()).into(),
+ dummy_description(),
+ None,
+ None,
+ ));
+
+ assert_ok!(Afloat::create_sell_order(
+ RawOrigin::Signed(user.clone()).into(),
+ item_id,
+ 10000,
+ 10,
+ ));
+
+ let offer_id = GatedMarketplace::offers_by_item(0, 0).iter().next().unwrap().clone();
+
+ assert_ok!(Afloat::take_sell_order(
+ RawOrigin::Signed(other_user.clone()).into(),
+ offer_id,
+ ));
+
+ assert_eq!(Afloat::do_get_afloat_balance(user.clone()), 9600); // 10000 - 400 (sell fee)
+ assert_eq!(Afloat::do_get_afloat_balance(1), 400); // 400 (sell fee)
+ });
+
+}
+
+#[test]
+fn create_buy_order_works() {
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ let other_user = new_account(4);
+ let item_id = 0;
+
+ Balances::make_free_balance_be(&user, 100);
+ Balances::make_free_balance_be(&other_user, 100);
+
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 0,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args.clone()));
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(other_user.clone()).into(), args.clone()));
+
+ assert_ok!(Afloat::set_afloat_balance(RuntimeOrigin::signed(1), 4, 100000));
+
+ assert_ok!(Afloat::create_tax_credit(
+ RawOrigin::Signed(user.clone()).into(),
+ dummy_description(),
+ None,
+ None,
+ ));
+
+ assert_ok!(Afloat::create_buy_order(
+ RawOrigin::Signed(other_user.clone()).into(),
+ item_id,
+ 10000,
+ 10,
+ ));
+
+ });
+
+}
+
+#[test]
+fn take_buy_order_works(){
+ new_test_ext().execute_with(|| {
+ let user = new_account(3);
+ let other_user = new_account(4);
+ let item_id = 0;
+
+ Balances::make_free_balance_be(&user, 100);
+ Balances::make_free_balance_be(&other_user, 100);
+
+
+ let args = SignUpArgs::BuyerOrSeller {
+ first_name: ShortString::try_from(b"Afloat".to_vec()).unwrap(),
+ last_name: ShortString::try_from(b"User".to_vec()).unwrap(),
+ email: LongString::try_from(b"Afloatuser@gmail.com".to_vec()).unwrap(),
+ state: 0,
+ };
+
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(user.clone()).into(), args.clone()));
+ assert_ok!(Afloat::sign_up(RawOrigin::Signed(other_user.clone()).into(), args.clone()));
+
+ assert_ok!(Afloat::set_afloat_balance(RuntimeOrigin::signed(1), 4, 100000));
+
+ assert_ok!(Afloat::create_tax_credit(
+ RawOrigin::Signed(user.clone()).into(),
+ dummy_description(),
+ None,
+ None,
+ ));
+
+ assert_ok!(Afloat::create_buy_order(
+ RawOrigin::Signed(other_user.clone()).into(),
+ item_id,
+ 10000,
+ 10,
+ ));
+
+ let offer_id = GatedMarketplace::offers_by_item(0, 0).iter().next().unwrap().clone();
+
+ assert_ok!(Afloat::take_buy_order(
+ RawOrigin::Signed(user.clone()).into(),
+ offer_id,
+ ));
+
+ assert_eq!(Afloat::do_get_afloat_balance(user.clone()), 9800); // 10000 - 200 (buy fee)
+ assert_eq!(Afloat::do_get_afloat_balance(1), 200); // 200 (buy fee)
+
+ });
+
+}
diff --git a/pallets/afloat/src/types.rs b/pallets/afloat/src/types.rs
index d0fca147..a1a0db95 100644
--- a/pallets/afloat/src/types.rs
+++ b/pallets/afloat/src/types.rs
@@ -1,61 +1,44 @@
use super::*;
use frame_support::pallet_prelude::*;
+use frame_support::sp_io::hashing::blake2_256;
+use sp_runtime::sp_std::vec::Vec;
-
-pub type ShortString = BoundedVec>;
+pub type ShortString = BoundedVec>;
pub type LongString = BoundedVec>;
pub type Date = u64;
pub type CollectionId = u32;
+pub type StorageId = [u8; 32];
+
+// ! User structures
#[derive(CloneNoBound, Encode, Decode, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen, PartialEq)]
#[scale_info(skip_type_params(T))]
#[codec(mel_bound())]
pub struct User {
- pub first_name: ShortString,
- pub last_name: ShortString,
- pub email: LongString,
- pub lang_key: ShortString,
+ pub cid: ShortString,
+ pub group: ShortString, // only can be modified when the user is registered (can not be modified)
pub created_by: Option,
pub created_date: Option,
pub last_modified_by: Option,
pub last_modified_date: Option,
- pub phone: Option,
- pub credits_needed: u32,
- pub cpa_id: ShortString,
- pub tax_authority_id: u32,
- pub lock_expiration_date: Option,
}
impl User {
pub fn new(
- first_name: ShortString,
- last_name: ShortString,
- email: LongString,
- lang_key: ShortString,
+ cid: ShortString,
+ group: ShortString,
created_by: Option,
created_date: Option,
last_modified_by: Option,
last_modified_date: Option,
- phone: Option,
- credits_needed: u32,
- cpa_id: ShortString,
- tax_authority_id: u32,
- lock_expiration_date: Option,
) -> Self {
Self {
- first_name,
- last_name,
- email,
- lang_key,
+ cid,
+ group,
created_by,
created_date,
last_modified_by,
last_modified_date,
- phone,
- credits_needed,
- cpa_id,
- tax_authority_id,
- lock_expiration_date,
}
}
}
@@ -65,14 +48,11 @@ impl User {
#[codec(mel_bound())]
pub enum UpdateUserArgs {
Edit {
- first_name: Option,
- last_name: Option,
- email: Option,
- lang_key: Option,
- phone: Option>,
- credits_needed: Option,
- cpa_id: Option,
- state: Option,
+ cid: ShortString,
+ },
+ AdminEdit {
+ cid: ShortString,
+ group: ShortString,
},
Delete,
}
@@ -82,16 +62,203 @@ pub enum UpdateUserArgs {
#[codec(mel_bound())]
pub enum SignUpArgs {
BuyerOrSeller {
- first_name: ShortString,
- last_name: ShortString,
- email: LongString,
- state: u32,
+ cid: ShortString,
+ group: ShortString,
},
CPA {
- first_name: ShortString,
- last_name: ShortString,
- email: LongString,
- license_number: ShortString,
- state: u32,
+ cid: ShortString,
+ group: ShortString,
+ },
+}
+
+// ! Offer structures
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebugNoBound, MaxEncodedLen, TypeInfo, Copy,)]
+pub enum OfferStatus {
+ MATCHED,
+ TF_FILLED,
+ TF_PENDING_SIGNATURE,
+ TF_SIGNED,
+ TF_AGENCY_SUBMITTED,
+ TF_AGENCY_APPROVED,
+ AFLOAT_APPROVED,
+}
+
+impl Default for OfferStatus {
+ fn default() -> Self {
+ OfferStatus::TF_PENDING_SIGNATURE
+ }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebugNoBound, MaxEncodedLen, TypeInfo, Copy,)]
+pub enum OfferType {
+ Sell,
+ Buy
+}
+
+impl Default for OfferType {
+ fn default() -> Self {
+ OfferType::Sell
+ }
+}
+
+#[derive(CloneNoBound, Encode, Decode, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen, PartialEq)]
+#[scale_info(skip_type_params(T))]
+#[codec(mel_bound())]
+pub struct Offer {
+ pub tax_credit_amount: u32,
+ pub tax_credit_amount_remaining: u32,
+ pub price_per_credit: T::Balance,
+ pub expiration_date: Date,
+ pub creation_date: Date,
+ pub cancellation_date: Option,
+ // pub fee: T::Balance,
+ pub tax_credit_id: ::ItemId,
+ pub creator_id: T::AccountId,
+ pub status: OfferStatus,
+ pub offer_type: OfferType,
+}
+
+impl Offer {
+ pub fn new(
+ tax_credit_amount: u32,
+ tax_credit_amount_remaining: u32,
+ price_per_credit: T::Balance,
+ creation_date: Date,
+ cancellation_date: Option,
+ // fee: T::Balance,
+ tax_credit_id: ::ItemId,
+ creator_id: T::AccountId,
+ expiration_date: Date,
+ status: OfferStatus,
+ offer_type: OfferType,
+ ) -> Self {
+ Self {
+ tax_credit_amount,
+ tax_credit_amount_remaining,
+ price_per_credit,
+ creation_date,
+ expiration_date: expiration_date,
+ cancellation_date,
+ // fee,
+ tax_credit_id,
+ creator_id,
+ status,
+ offer_type,
+ }
+ }
+}
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebugNoBound, TypeInfo)]
+#[scale_info(skip_type_params(T))]
+#[codec(mel_bound())]
+pub enum CreateOfferArgs {
+ Sell {
+ tax_credit_amount: u32,
+ price_per_credit: T::Balance,
+ tax_credit_id: ::ItemId,
+ expiration_date: Date,
},
+ Buy {
+ tax_credit_amount: u32,
+ price_per_credit: T::Balance,
+ tax_credit_id: ::ItemId,
+ expiration_date: Date,
+ },
+}
+
+// ! Transaction structures
+
+#[derive(CloneNoBound, Encode, Decode, RuntimeDebugNoBound, TypeInfo, MaxEncodedLen, PartialEq)]
+#[scale_info(skip_type_params(T))]
+#[codec(mel_bound())]
+pub struct Transaction {
+ pub tax_credit_amount: u32,
+ pub price_per_credit: u32,
+ pub total_price: u32,
+ pub fee: u32,
+ pub creation_date: Date,
+ pub cancellation_date: Option,
+ pub tax_credit_id: u32,
+ pub seller_id: T::AccountId,
+ pub buyer_id: T::AccountId,
+ pub offer_id: StorageId,
+ pub seller_confirmation_date: Option,
+ pub buyer_confirmation_date: Option,
+}
+
+// ! Roles structures
+
+#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebugNoBound, MaxEncodedLen, TypeInfo, Copy,)]
+pub enum AfloatRole {
+ Owner,
+ Admin,
+ BuyerOrSeller,
+ CPA,
+}
+
+impl Default for AfloatRole {
+ fn default() -> Self {
+ AfloatRole::BuyerOrSeller
+ }
+}
+
+impl AfloatRole {
+ pub fn to_vec(self) -> Vec {
+ match self {
+ Self::Owner => "Owner".as_bytes().to_vec(),
+ Self::Admin => "Admin".as_bytes().to_vec(),
+ Self::BuyerOrSeller => "BuyerOrSeller".as_bytes().to_vec(),
+ Self::CPA => "CPA".as_bytes().to_vec(),
+ }
+ }
+
+ pub fn id(&self) -> [u8; 32] {
+ self.to_vec().using_encoded(blake2_256)
+ }
+
+ pub fn enum_to_vec() -> Vec> {
+ use crate::types::AfloatRole::*;
+ [
+ Owner.to_vec(),
+ Admin.to_vec(),
+ BuyerOrSeller.to_vec(),
+ CPA.to_vec(),
+ ]
+ .to_vec()
+ }
+}
+
+#[derive(
+ Encode, Decode, Clone, Eq, PartialEq, RuntimeDebugNoBound, MaxEncodedLen, TypeInfo, Copy,
+)]
+pub enum Permission {
+ CreateUser,
+ EditUser,
+ DeleteUser,
+}
+
+impl Permission {
+ pub fn to_vec(self) -> Vec {
+ match self {
+ Self::CreateUser => "CreateUser".as_bytes().to_vec(),
+ Self::EditUser => "EditUser".as_bytes().to_vec(),
+ Self::DeleteUser => "DeleteUser".as_bytes().to_vec(),
+ }
+ }
+
+ pub fn id(&self) -> [u8; 32] {
+ self.to_vec().using_encoded(blake2_256)
+ }
+
+ pub fn admin_permissions() -> Vec> {
+ use crate::types::Permission::*;
+ let admin_permissions = [
+ CreateUser.to_vec(),
+ EditUser.to_vec(),
+ DeleteUser.to_vec(),
+ ]
+ .to_vec();
+ admin_permissions
+ }
}
diff --git a/pallets/gated-marketplace/Cargo.toml b/pallets/gated-marketplace/Cargo.toml
index f68ac2b1..b90db52b 100644
--- a/pallets/gated-marketplace/Cargo.toml
+++ b/pallets/gated-marketplace/Cargo.toml
@@ -30,6 +30,7 @@ pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "p
pallet-timestamp = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.38", default-features = false }
pallet-fruniques = { path = "../fruniques", default-features = false, version = "0.1.0-dev" }
pallet-rbac = { path = "../rbac/", default-features = false, version = "4.0.0-dev" }
+pallet-mapped-assets = { path = "../mapped-assets/", default-features = false, version = "4.0.0-dev" }
[dev-dependencies]
sp-core = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.38", default-features = false }
@@ -49,7 +50,8 @@ std = [
"pallet-uniques/std",
"pallet-fruniques/std",
"pallet-timestamp/std",
- "pallet-rbac/std"
+ "pallet-rbac/std",
+ "pallet-mapped-assets/std"
]
runtime-benchmarks = ["frame-benchmarking/runtime-benchmarks"]
try-runtime = ["frame-support/try-runtime"]
diff --git a/pallets/gated-marketplace/src/functions.rs b/pallets/gated-marketplace/src/functions.rs
index 9bc0cd19..e8eca812 100644
--- a/pallets/gated-marketplace/src/functions.rs
+++ b/pallets/gated-marketplace/src/functions.rs
@@ -5,11 +5,11 @@ use frame_support::sp_io::hashing::blake2_256;
use pallet_rbac::types::*;
use scale_info::prelude::vec; // vec![] macro
use sp_runtime::sp_std::vec::Vec; // vec primitive
-
-use frame_support::traits::Currency;
-use frame_support::traits::ExistenceRequirement::KeepAlive;
+use frame_system::pallet_prelude::*;
use frame_support::traits::Time;
use sp_runtime::Permill;
+use sp_runtime::traits::StaticLookup;
+use frame_system::RawOrigin;
impl Pallet {
pub fn do_initial_setup() -> DispatchResult {
@@ -50,17 +50,30 @@ impl Pallet {
}
pub fn do_create_marketplace(
- owner: T::AccountId,
+ origin: OriginFor,
admin: T::AccountId,
marketplace: Marketplace,
) -> DispatchResult {
+ let owner = ensure_signed(origin.clone())?;
// Gen market id
let marketplace_id = marketplace.using_encoded(blake2_256);
+ //Get asset id
+ let asset_id = marketplace.asset_id;
+ let min_balance: T::Balance = T::Balance::from(1u32);
+
+
// ensure the generated id is unique
ensure!(
!>::contains_key(marketplace_id),
Error::::MarketplaceAlreadyExists
);
+ // Create asset
+ pallet_mapped_assets::Pallet::::create(
+ origin,
+ asset_id,
+ T::Lookup::unlookup(owner.clone()),
+ min_balance,
+ )?;
//Insert on marketplaces and marketplaces by auth
::Rbac::create_scope(Self::pallet_id(), marketplace_id)?;
Self::insert_in_auth_market_lists(owner.clone(), MarketplaceRole::Owner, marketplace_id)?;
@@ -327,9 +340,9 @@ impl Pallet