git.delta.rocks / unique-network / refs/commits / 5c8bf09b7657

difftreelog

add extra genesis

str-mv2020-09-30parent: #0053d9a.patch.diff
in: master

3 files changed

modifiednode/src/chain_spec.rsdiffbeforeafterboth
1// use nft_runtime::{
2// AccountId, AuraConfig, BalancesConfig, GenesisConfig, GrandpaConfig, Signature, SudoConfig,
3// SystemConfig, WASM_BINARY,
4// };
5// use nft_runtime::{ContractsConfig, ContractsSchedule, NftConfig, CollectionType};
1use nft_runtime::{6use nft_runtime::*;
2 AccountId, AuraConfig, BalancesConfig, GenesisConfig, GrandpaConfig, Signature, SudoConfig,
3 SystemConfig, WASM_BINARY,
4};
5use nft_runtime::{ContractsConfig, ContractsSchedule};
6use sc_service::ChainType;7use sc_service::ChainType;
7use sp_consensus_aura::sr25519::AuthorityId as AuraId;8use sp_consensus_aura::sr25519::AuthorityId as AuraId;
8use sp_core::{sr25519, Pair, Public};9use sp_core::{sr25519, Pair, Public};
128 .collect(),129 .collect(),
129 }),130 }),
130 sudo: Some(SudoConfig { key: root_key }),131 sudo: Some(SudoConfig { key: root_key }),
132 nft: Some(NftConfig {
133 collection: vec![(1, CollectionType {
134 owner: get_account_id_from_seed::<sr25519::Public>("Alice"),
135 mode: CollectionMode::NFT(50),
136 access: AccessMode::Normal,
137 decimal_points: 0,
138 name: vec!(),
139 description: vec!(),
140 token_prefix: vec!(),
141 custom_data_size: 50,
142 mint_mode: false,
143 offchain_schema: vec!(),
144 sponsor: get_account_id_from_seed::<sr25519::Public>("Alice"),
145 unconfirmed_sponsor: get_account_id_from_seed::<sr25519::Public>("Alice"),
146 })],
147 nft_item_id: vec!(),
148 fungible_item_id: vec!(),
149 refungible_item_id: vec!(),
150 }),
131 contracts: Some(ContractsConfig {151 contracts: Some(ContractsConfig {
132 current_schedule: ContractsSchedule {152 current_schedule: ContractsSchedule {
133 enable_println,153 enable_println,
modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
1#![cfg_attr(not(feature = "std"), no_std)]1#![cfg_attr(not(feature = "std"), no_std)]
22
3/// For more guidance on Substrate FRAME, see the example pallet3#[cfg(feature = "std")]
4/// https://github.com/paritytech/substrate/blob/master/frame/example/src/lib.rs4pub use serde::*;
5
5use codec::{Decode, Encode};6use codec::{Decode, Encode};
6pub use frame_support::{7pub use frame_support::{
32 },33 },
33 FixedPointOperand, FixedU128,34 FixedPointOperand, FixedU128,
34};35};
35use sp_std::prelude::*;
3636
37#[cfg(test)]37#[cfg(test)]
38mod mock;38mod mock;
3939
40#[cfg(test)]40#[cfg(test)]
41mod tests;41mod tests;
4242
43#[derive(Encode, Decode, Debug, Eq, Clone, PartialEq)]43#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]
44#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
44pub enum CollectionMode {45pub enum CollectionMode {
45 Invalid,46 Invalid,
46 // custom data size47 // custom data size
62 }63 }
63}64}
6465
65#[derive(Encode, Decode, Debug, Clone, PartialEq)]66#[derive(Encode, Decode, Eq, Debug, Clone, PartialEq)]
67#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
66pub enum AccessMode {68pub enum AccessMode {
67 Normal,69 Normal,
68 WhiteList,70 WhiteList,
79 }81 }
80}82}
8183
82#[derive(Encode, Decode, Default, Clone, PartialEq)]84#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
83#[cfg_attr(feature = "std", derive(Debug))]85#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
84pub struct Ownership<AccountId> {86pub struct Ownership<AccountId> {
85 pub owner: AccountId,87 pub owner: AccountId,
86 pub fraction: u128,88 pub fraction: u128,
87}89}
8890
89#[derive(Encode, Decode, Default, Clone, PartialEq)]91#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
90#[cfg_attr(feature = "std", derive(Debug))]92#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
91pub struct CollectionType<AccountId> {93pub struct CollectionType<AccountId> {
92 pub owner: AccountId,94 pub owner: AccountId,
93 pub mode: CollectionMode,95 pub mode: CollectionMode,
103 pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship105 pub unconfirmed_sponsor: AccountId, // Sponsor address that has not yet confirmed sponsorship
104}106}
105107
106#[derive(Encode, Decode, Default, Clone, PartialEq)]108#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
107#[cfg_attr(feature = "std", derive(Debug))]109#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
108pub struct CollectionAdminsType<AccountId> {110pub struct CollectionAdminsType<AccountId> {
109 pub admin: AccountId,111 pub admin: AccountId,
110 pub collection_id: u64,112 pub collection_id: u64,
111}113}
112114
113#[derive(Encode, Decode, Default, Clone, PartialEq)]115#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
114#[cfg_attr(feature = "std", derive(Debug))]116#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
115pub struct NftItemType<AccountId> {117pub struct NftItemType<AccountId> {
116 pub collection: u64,118 pub collection: u64,
117 pub owner: AccountId,119 pub owner: AccountId,
118 pub data: Vec<u8>,120 pub data: Vec<u8>,
119}121}
120122
121#[derive(Encode, Decode, Default, Clone, PartialEq)]123#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
122#[cfg_attr(feature = "std", derive(Debug))]124#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
123pub struct FungibleItemType<AccountId> {125pub struct FungibleItemType<AccountId> {
124 pub collection: u64,126 pub collection: u64,
125 pub owner: AccountId,127 pub owner: AccountId,
126 pub value: u128,128 pub value: u128,
127}129}
128130
129#[derive(Encode, Decode, Default, Clone, PartialEq)]131#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
130#[cfg_attr(feature = "std", derive(Debug))]132#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
131pub struct ReFungibleItemType<AccountId> {133pub struct ReFungibleItemType<AccountId> {
132 pub collection: u64,134 pub collection: u64,
133 pub owner: Vec<Ownership<AccountId>>,135 pub owner: Vec<Ownership<AccountId>>,
134 pub data: Vec<u8>,136 pub data: Vec<u8>,
135}137}
136138
137#[derive(Encode, Decode, Default, Clone, PartialEq)]139#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
138#[cfg_attr(feature = "std", derive(Debug))]140#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
139pub struct ApprovePermissions<AccountId> {141pub struct ApprovePermissions<AccountId> {
140 pub approved: AccountId,142 pub approved: AccountId,
141 pub amount: u64,143 pub amount: u64,
142}144}
143145
144#[derive(Encode, Decode, Default, Clone, PartialEq)]146#[derive(Encode, Decode, Default, Debug, Clone, PartialEq)]
145#[cfg_attr(feature = "std", derive(Debug))]147#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
146pub struct VestingItem<AccountId, Moment> {148pub struct VestingItem<AccountId, Moment> {
147 pub sender: AccountId,149 pub sender: AccountId,
148 pub recipient: AccountId,150 pub recipient: AccountId,
165 ChainVersion: u64;167 ChainVersion: u64;
166 ItemListIndex: map hasher(blake2_128_concat) u64 => u64;168 ItemListIndex: map hasher(blake2_128_concat) u64 => u64;
167169
168 pub Collection get(fn collection): map hasher(identity) u64 => CollectionType<T::AccountId>;170 pub Collection get(fn collection) config(): map hasher(identity) u64 => CollectionType<T::AccountId>;
169 pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;171 pub AdminList get(fn admin_list_collection): map hasher(identity) u64 => Vec<T::AccountId>;
170 pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;172 pub WhiteList get(fn white_list): map hasher(identity) u64 => Vec<T::AccountId>;
171173
176 pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;178 pub ApprovedList get(fn approved): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) (u64, T::AccountId) => Vec<ApprovePermissions<T::AccountId>>;
177179
178 /// Item collections180 /// Item collections
179 pub NftItemList get(fn nft_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;181 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => NftItemType<T::AccountId>;
180 pub FungibleItemList get(fn fungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;182 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => FungibleItemType<T::AccountId>;
181 pub ReFungibleItemList get(fn refungible_item_id): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;183 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) u64 => ReFungibleItemType<T::AccountId>;
182184
183 /// Index list185 /// Index list
184 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;186 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) u64, hasher(blake2_128_concat) T::AccountId => Vec<u64>;
187 pub ContractSponsor get(fn contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;189 pub ContractSponsor get(fn contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;
188 pub UnconfirmedContractSponsor get(fn unconfirmed_contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;190 pub UnconfirmedContractSponsor get(fn unconfirmed_contract_sponsor): map hasher(identity) T::AccountId => T::AccountId;
189 }191 }
192 add_extra_genesis {
193 build(|config: &GenesisConfig<T>| {
194 // Modification of storage
195 for (_num, _c) in &config.collection {
196 <Module<T>>::init_collection(_c);
197 }
198
199 for (_num, _q, _i) in &config.nft_item_id {
200 <Module<T>>::init_nft_token(_i);
201 }
202
203 for (_num, _q, _i) in &config.fungible_item_id {
204 <Module<T>>::init_fungible_token(_i);
205 }
206
207 for (_num, _q, _i) in &config.refungible_item_id {
208 <Module<T>>::init_refungible_token(_i);
209 }
210 })
211 }
190}212}
191213
192decl_event!(214decl_event!(
568590
569 let sender = ensure_signed(origin)?;591 let sender = ensure_signed(origin)?;
592
593 // Check access and mint mode
594 let target_collection = <Collection<T>>::get(collection_id);
570 Self::check_white_list(collection_id, sender.clone())?;595 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {
596
597 Self::check_white_list(collection_id, sender.clone())?;
571 Self::check_white_list(collection_id, recipient.clone())?;598 Self::check_white_list(collection_id, recipient.clone())?;
572 let target_collection = <Collection<T>>::get(collection_id);599 ensure!(target_collection.access == AccessMode::WhiteList, "Collection must have WhiteList access");
600 ensure!(target_collection.mint_mode == true, "Collection must be in mint mode");
601 }
573602
574 match target_collection.mode603 match target_collection.mode
575 {604 {
623
624 ensure!(approved_list_exists, "Only approved addresses can call this method");652 ensure!(approved_list_exists, "Only approved addresses can call this method");
625
626 Self::check_white_list(collection_id, from.clone())?;
627 Self::check_white_list(collection_id, recipient.clone())?;
628653
629 let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));654 let list_itm = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()));
630 let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());655 let opt_item = list_itm.iter().find(|i| i.approved == sender.clone());
631 ensure!(opt_item.is_some(), "No approve found");656 ensure!(opt_item.is_some(), "No approve found");
632 ensure!(opt_item.unwrap().amount >= value, "Requested value more than approved");657 ensure!(opt_item.unwrap().amount >= value, "Requested value more than approved");
658
659 // Check access and mint mode
660 let target_collection = <Collection<T>>::get(collection_id);
661 if !Self::is_owner_or_admin_permissions(collection_id, sender.clone()) {
662
663 Self::check_white_list(collection_id, sender.clone())?;
664 Self::check_white_list(collection_id, recipient.clone())?;
665 ensure!(target_collection.access == AccessMode::WhiteList, "Collection must have WhiteList access");
666 ensure!(target_collection.mint_mode == true, "Collection must be in mint mode");
667 }
633668
634 // remove approve669 // remove approve
635 let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))670 let approve_list: Vec<ApprovePermissions<T::AccountId>> = <ApprovedList<T>>::get(collection_id, (item_id, from.clone()))
636 .into_iter().filter(|i| i.approved != sender.clone()).collect();671 .into_iter().filter(|i| i.approved != sender.clone()).collect();
637 <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);672 <ApprovedList<T>>::insert(collection_id, (item_id, from.clone()), approve_list);
638673
639 let target_collection = <Collection<T>>::get(collection_id);
640674
641 match target_collection.mode675 match target_collection.mode
642 {676 {
1114 Ok(())1148 Ok(())
1115 }1149 }
1150
1151 fn init_collection(item: &CollectionType<T::AccountId>){
1152
1153 // check params
1154 assert!(item.decimal_points <= 4, "decimal_points parameter must be lower than 4");
1155 assert!(item.name.len() <= 64, "Collection name can not be longer than 63 char");
1156 assert!(item.name.len() <= 256, "Collection description can not be longer than 255 char");
1157 assert!(item.token_prefix.len() <= 16, "Token prefix can not be longer than 15 char");
1158
1159 // Generate next collection ID
1160 let next_id = CreatedCollectionCount::get()
1161 .checked_add(1)
1162 .expect("collection id error");
1163
1164 CreatedCollectionCount::put(next_id);
1165 }
1166
1167 fn init_nft_token(item: &NftItemType<T::AccountId>){
1168
1169 let current_index = <ItemListIndex>::get(item.collection)
1170 .checked_add(1)
1171 .expect("Item list index id error");
1172
1173 let item_owner = item.owner.clone();
1174 let collection_id = item.collection.clone();
1175 Self::add_token_index(collection_id, current_index, item.owner.clone()).unwrap();
1176
1177 <ItemListIndex>::insert(collection_id, current_index);
1178
1179 // Update balance
1180 let new_balance = <Balance<T>>::get(collection_id, item_owner.clone())
1181 .checked_add(1)
1182 .unwrap();
1183 <Balance<T>>::insert(collection_id, item_owner.clone(), new_balance);
1184 }
1185
1186 fn init_fungible_token(item: &FungibleItemType<T::AccountId>){
1187
1188 let current_index = <ItemListIndex>::get(item.collection)
1189 .checked_add(1)
1190 .expect("Item list index id error");
1191 let owner = item.owner.clone();
1192 let value = item.value as u64;
1193
1194 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();
1195
1196 <ItemListIndex>::insert(item.collection, current_index);
1197
1198 // Update balance
1199 let new_balance = <Balance<T>>::get(item.collection, owner.clone())
1200 .checked_add(value)
1201 .unwrap();
1202 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);
1203 }
1204
1205 fn init_refungible_token(item: &ReFungibleItemType<T::AccountId>){
1206
1207 let current_index = <ItemListIndex>::get(item.collection)
1208 .checked_add(1)
1209 .expect("Item list index id error");
1210
1211 let value = item.owner.first().unwrap().fraction as u64;
1212 let owner = item.owner.first().unwrap().owner.clone();
1213
1214 Self::add_token_index(item.collection, current_index, owner.clone()).unwrap();
1215
1216 <ItemListIndex>::insert(item.collection, current_index);
1217
1218 // Update balance
1219 let new_balance = <Balance<T>>::get(item.collection, owner.clone())
1220 .checked_add(value)
1221 .unwrap();
1222 <Balance<T>>::insert(item.collection, owner.clone(), new_balance);
1223 }
11161224
1117 fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {1225 fn add_token_index(collection_id: u64, item_index: u64, owner: T::AccountId) -> DispatchResult {
1118 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());1226 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.clone());
modifiedruntime/src/lib.rsdiffbeforeafterboth
5353
54pub use timestamp::Call as TimestampCall;54pub use timestamp::Call as TimestampCall;
5555
56/// Importing a nft pallet56/// Re-export a nft pallet
57/// TODO: Check this re-export. Is this safe and good style?
58extern crate nft;
57pub use nft;59pub use nft::*;
5860
59/// An index to a block.61/// An index to a block.
60pub type BlockNumber = u32;62pub type BlockNumber = u32;
318 Balances: balances::{Module, Call, Storage, Config<T>, Event<T>},320 Balances: balances::{Module, Call, Storage, Config<T>, Event<T>},
319 TransactionPayment: transaction_payment::{Module, Storage},321 TransactionPayment: transaction_payment::{Module, Storage},
320 Sudo: sudo::{Module, Call, Config<T>, Storage, Event<T>},322 Sudo: sudo::{Module, Call, Config<T>, Storage, Event<T>},
321 Nft: nft::{Module, Call, Storage, Event<T>},323 Nft: nft::{Module, Call, Config<T>, Storage, Event<T>},
322 }324 }
323);325);
324326