`424f9cb7a9fa`

3 files changed

modifiedpallets/nft/src/benchmarking.rsdiff before after both

165            let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();165            let token_prefix1: Vec<u8> = b"token_prefix1".to_vec();
166            let mode: CollectionMode = CollectionMode::NFT;166            let mode: CollectionMode = CollectionMode::NFT;
167            let caller: T::AccountId = T::AccountId::from(whitelisted_caller());167            let caller: T::AccountId = T::AccountId::from(whitelisted_caller());
168            let nft_data = CreateNftData {168            let mut nft_data = CreateNftData {
169                const_data: vec![],169                const_data: vec![],
170                variable_data: vec![]170                variable_data: vec![]
171            };171            };
172            for i in 0..1998 {172            for i in 0..1998 {
173                nft_data.const_data.push(10);173                nft_data.const_data.push(10);
174                nft_data.variable_data.push(10);174                nft_data.variable_data.push(10);
175            }175            }
176            let mut data = CreateItemData::NFT(nft_data);176            let data = CreateItemData::NFT(nft_data);
177            Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;177            Nft::<T>::create_collection(RawOrigin::Signed(caller.clone()).into(), col_name1.clone(), col_desc1.clone(), token_prefix1.clone(), mode.clone())?;
178178
179        }: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)179        }: create_item(RawOrigin::Signed(caller.clone()), 2, caller.clone(), data)

modifiedpallets/nft/src/lib.rsdiff before after both

837            let target_collection = <Collection<T>>::get(collection_id);837            let target_collection = <Collection<T>>::get(collection_id);
838838
839            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;839            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;
840            Self::validate_create_item_args(&target_collection, &properties)?;840            Self::validate_create_item_args(&target_collection, &data)?;
841            Self::create_item_no_validation(collection_id, &target_collection, &properties, &owner)?;841            Self::create_item_no_validation(collection_id, &target_collection, owner, data)?;
842842
843            Ok(())843            Ok(())
844        }844        }
858        /// 858        /// 
859        /// * collection_id: ID of the collection.859        /// * collection_id: ID of the collection.
860        /// 860        /// 
861        /// * properties: Array items properties. Each property is an array of bytes itself, see [create_item].861        /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].
862        /// 862        /// 
863        /// * owner: Address, initial owner of the NFT.863        /// * owner: Address, initial owner of the NFT.
864        #[weight = 0]864        #[weight = T::WeightInfo::create_item(items_data.into_iter()
865                               .map(|data| { data.len() })
866                               .sum())]
865        pub fn create_multiple_items(origin, collection_id: u64, properties: Vec<Vec<u8>>, owner: T::AccountId) -> DispatchResult {867        pub fn create_multiple_items(origin, collection_id: u64, owner: T::AccountId, items_data: Vec<CreateItemData>) -> DispatchResult {
866868
867            ensure!(properties.len() > 0, "Length of items properties must be greater than 0.");869            ensure!(items_data.len() > 0, "Length of items properties must be greater than 0.");
868            let sender = ensure_signed(origin)?;870            let sender = ensure_signed(origin)?;
869871
870            Self::collection_exists(collection_id)?;872            Self::collection_exists(collection_id)?;
871            let target_collection = <Collection<T>>::get(collection_id);873            let target_collection = <Collection<T>>::get(collection_id);
872874
873            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;875            Self::can_create_items_in_collection(collection_id, &target_collection, &sender, &owner)?;
874876
875            for prop in &properties {877            for data in &items_data {
876                Self::validate_create_item_args(&target_collection, prop)?;878                Self::validate_create_item_args(&target_collection, data)?;
877            }879            }
878            for prop in &properties {880            for data in &items_data {
879                Self::create_item_no_validation(collection_id, &target_collection, prop, &owner)?;881                Self::create_item_no_validation(collection_id, &target_collection, owner.clone(), data.clone())?;
880            }882            }
881883
882            Ok(())884            Ok(())
1290        Ok(())1292        Ok(())
1291    }1293    }
12921294
1293    fn validate_create_item_args(collection: &CollectionType<T::AccountId>, properties: &Vec<u8>) -> DispatchResult {1295    fn validate_create_item_args(target_collection: &CollectionType<T::AccountId>, data: &CreateItemData) -> DispatchResult {
1294
1295        match collection.mode1296        match target_collection.mode
1296        {1297        {
1297            CollectionMode::NFT(_) => {1298            CollectionMode::NFT => {
12981299                if let CreateItemData::NFT(data) = data {
1299                // check size1300                    // check sizes
1301                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");
1300                ensure!(collection.custom_data_size >= properties.len() as u32, "Size of item is too large")1302                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");
1303                } else {
1304                    fail!("Not NFT item data used to mint in NFT collection.");
1305                }
1301            },1306            },
1302            CollectionMode::Fungible(_) => {1307            CollectionMode::Fungible(_) => {
13031308                if let CreateItemData::Fungible(_) = data {
1304                // check size1309                } else {
1305                ensure!(properties.len() as u32 == 0, "Size of item must be 0 with fungible type")1310                    fail!("Not Fungible item data used to mint in Fungible collection.");
1311                }
1306            },1312            },
1307            CollectionMode::ReFungible(_, _) => {1313            CollectionMode::ReFungible(_) => {
1314                if let CreateItemData::ReFungible(data) = data {
13081315
1309                // check size1316                    // check sizes
1317                    ensure!(ChainLimit::get().custom_data_limit >= data.const_data.len() as u32, "const_data exceeded data limit.");
1310                ensure!(collection.custom_data_size >= properties.len() as u32, "Size of item is too large")1318                    ensure!(ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32, "variable_data exceeded data limit.");
1319                } else {
1320                    fail!("Not Re Fungible item data used to mint in Re Fungible collection.");
1321                }
1311            },1322            },
1312            _ => {1323            _ => { fail!("Unexpected collection type."); }
1313                fail!("Unexpected collection mode")
1314            }
1315        }1324        };
13161325
1317        Ok(())1326        Ok(())
1318    }1327    }
13191328
1320    fn create_item_no_validation(collection_id: u64, collection: &CollectionType<T::AccountId>, properties: &Vec<u8>, owner: &T::AccountId) -> DispatchResult {1329    fn create_item_no_validation(collection_id: u64, collection: &CollectionType<T::AccountId>, owner: T::AccountId, data: CreateItemData) -> DispatchResult {
1321        match collection.mode1330        match data
1322        {1331        {
1323            CollectionMode::NFT(_) => {1332            CreateItemData::NFT(data) => {
1324
1325                // Create nft item
1326                let item = NftItemType {1333                let item = NftItemType {
1327                    collection: collection_id,1334                    collection: collection_id,
1328                    owner: owner.clone(),1335                    owner,
1336                    const_data: data.const_data,
1329                    data: properties.clone(),1337                    variable_data: data.variable_data
1330                };1338                };
13311339
1332                Self::add_nft_item(item)?;1340                Self::add_nft_item(item)?;
1333
1334            },1341            },
1335            CollectionMode::Fungible(_) => {1342            CreateItemData::Fungible(_) => {
1336
1337                let item = FungibleItemType {1343                let item = FungibleItemType {
1338                    collection: collection_id,1344                    collection: collection_id,
1339                    owner: owner.clone(),1345                    owner,
1340                    value: (10 as u128).pow(collection.decimal_points)1346                    value: (10 as u128).pow(collection.decimal_points)
1341                };1347                };
13421348
1343                Self::add_fungible_item(item)?;1349                Self::add_fungible_item(item)?;
1344            },1350            },
1345            CollectionMode::ReFungible(_, _) => {1351            CreateItemData::ReFungible(data) => {
1346
1347                let mut owner_list = Vec::new();1352                let mut owner_list = Vec::new();
1348                let value = (10 as u128).pow(collection.decimal_points);1353                let value = (10 as u128).pow(collection.decimal_points);
1351                let item = ReFungibleItemType {1356                let item = ReFungibleItemType {
1352                    collection: collection_id,1357                    collection: collection_id,
1353                    owner: owner_list,1358                    owner: owner_list,
1359                    const_data: data.const_data,
1354                    data: properties.clone()1360                    variable_data: data.variable_data
1355                };1361                };
13561362
1357                Self::add_refungible_item(item)?;1363                Self::add_refungible_item(item)?;
1358            },1364            }
1359            _ => { ensure!(1 == 0,"just error"); }
1360
1361        };1365        };
1366

modifiedpallets/nft/src/tests.rsdiff before after both

92#[test]92#[test]
93fn create_nft_multiple_items() {93fn create_nft_multiple_items() {
94    new_test_ext().execute_with(|| {94    new_test_ext().execute_with(|| {
95        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();95        default_limits();
96        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();96        
97        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
98        let mode: CollectionMode = CollectionMode::NFT(2000);97        create_test_collection(&CollectionMode::NFT, 1);
99
100        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
101            collection_numbers_limit: 10,
102            account_token_ownership_limit: 10,
103            collections_admins_limit: 5,
104            custom_data_limit: 2048,
105            nft_sponsor_transfer_timeout: 15,
106            fungible_sponsor_transfer_timeout: 15,
107            refungible_sponsor_transfer_timeout: 15,          
108        }));
10998
110        let origin1 = Origin::signed(1);99        let origin1 = Origin::signed(1);
111        assert_ok!(TemplateModule::create_collection(
112            origin1.clone(),
113            col_name1.clone(),
114            col_desc1.clone(),
115            token_prefix1.clone(),
116            mode
117        ));
118        assert_eq!(TemplateModule::collection(1).owner, 1);
119100
120        let properties = [[1, 2, 3].to_vec(), [3, 2, 1].to_vec(), [3, 3, 3].to_vec()].to_vec();101        let items_data = vec![default_nft_data(), default_nft_data(), default_nft_data()];
121102
122        assert_ok!(TemplateModule::create_multiple_items(103        assert_ok!(TemplateModule::create_multiple_items(
123            origin1.clone(),104            origin1.clone(),
124            1,105            1,
106            1,
125            properties.clone(),107            items_data.clone().into_iter().map(|d| { d.into() }).collect()
126            1
127        ));108        ));
128        for (index, data) in properties.iter().enumerate() {109        for (index, data) in items_data.iter().enumerate() {
129            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as u64).data, *data);110            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as u64).const_data.to_vec(), data.const_data);
111            assert_eq!(TemplateModule::nft_item_id(1, (index + 1) as u64).variable_data.to_vec(), data.variable_data);
130        }112        }
131    });113    });
132}114}
160#[test]142#[test]
161fn create_multiple_refungible_items() {143fn create_multiple_refungible_items() {
162    new_test_ext().execute_with(|| {144    new_test_ext().execute_with(|| {
163        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();145        default_limits();
164        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();146        
165        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
166        let mode: CollectionMode = CollectionMode::ReFungible(2000, 3);147        create_test_collection(&CollectionMode::ReFungible(3), 1);
167
168        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
169            collection_numbers_limit: 10,
170            account_token_ownership_limit: 10,
171            collections_admins_limit: 5,
172            custom_data_limit: 2048,
173            nft_sponsor_transfer_timeout: 15,
174            fungible_sponsor_transfer_timeout: 15,
175            refungible_sponsor_transfer_timeout: 15,          
176        }));
177148
178        let origin1 = Origin::signed(1);149        let origin1 = Origin::signed(1);
179        assert_ok!(TemplateModule::create_collection(
180            origin1.clone(),
181            col_name1.clone(),
182            col_desc1.clone(),
183            token_prefix1.clone(),
184            mode
185        ));
186        assert_eq!(TemplateModule::collection(1).owner, 1);
187150
188        let properties = [[1, 2, 3].to_vec(), [3, 2, 1].to_vec(), [3, 3, 3].to_vec()].to_vec();151        let items_data = vec![default_re_fungible_data(), default_re_fungible_data(), default_re_fungible_data()];
189152
190        assert_ok!(TemplateModule::create_multiple_items(153        assert_ok!(TemplateModule::create_multiple_items(
191            origin1.clone(),154            origin1.clone(),
192            1,155            1,
156            1,
193            properties.clone(),157            items_data.clone().into_iter().map(|d| { d.into() }).collect()
194            1
195        ));158        ));
196        for (index, data) in properties.iter().enumerate() {159        for (index, data) in items_data.iter().enumerate() {
197160
198            let item = TemplateModule::refungible_item_id(1, (index + 1) as u64);161            let item = TemplateModule::refungible_item_id(1, (index + 1) as u64);
199            assert_eq!(item.data, *data);162            assert_eq!(item.const_data.to_vec(), data.const_data);
163            assert_eq!(item.variable_data.to_vec(), data.variable_data);
200            assert_eq!(164            assert_eq!(
201                item.owner[0],165                item.owner[0],
202                Ownership {166                Ownership {
225#[test]189#[test]
226fn create_multiple_fungible_items() {190fn create_multiple_fungible_items() {
227    new_test_ext().execute_with(|| {191    new_test_ext().execute_with(|| {
228        let col_name1: Vec<u16> = "Test1\0".encode_utf16().collect::<Vec<u16>>();192        default_limits();
229        let col_desc1: Vec<u16> = "TestDescription1\0".encode_utf16().collect::<Vec<u16>>();193
230        let token_prefix1: Vec<u8> = b"token_prefix1\0".to_vec();
231        let mode: CollectionMode = CollectionMode::Fungible(3);194        create_test_collection(&CollectionMode::Fungible(3), 1);
232
233        assert_ok!(TemplateModule::set_chain_limits(RawOrigin::Root.into(), ChainLimits { 
234            collection_numbers_limit: 10,
235            account_token_ownership_limit: 10,
236            collections_admins_limit: 5,
237            custom_data_limit: 2048,
238            nft_sponsor_transfer_timeout: 15,
239            fungible_sponsor_transfer_timeout: 15,
240            refungible_sponsor_transfer_timeout: 15,          
241        }));
242195
243        let origin1 = Origin::signed(1);196        let origin1 = Origin::signed(1);
244        assert_ok!(TemplateModule::create_collection(
245            origin1.clone(),
246            col_name1.clone(),
247            col_desc1.clone(),
248            token_prefix1.clone(),
249            mode
250        ));
251        assert_eq!(TemplateModule::collection(1).owner, 1);
252197
253        let properties = [[].to_vec(), [].to_vec(), [].to_vec()].to_vec();198        let items_data = vec![default_fungible_data(), default_fungible_data(), default_fungible_data()];
254199
255        assert_ok!(TemplateModule::create_multiple_items(200        assert_ok!(TemplateModule::create_multiple_items(
256            origin1.clone(),201            origin1.clone(),
257            1,202            1,
203            1,
258            properties.clone(),204            items_data.clone().into_iter().map(|d| { d.into() }).collect()
259            1
260        ));205        ));
261        206        
262        for (index, _) in properties.iter().enumerate() {207        for (index, _) in items_data.iter().enumerate() {
263            assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as u64).owner, 1);208            assert_eq!(TemplateModule::fungible_item_id(1, (index + 1) as u64).owner, 1);
264        }209        }
265        assert_eq!(TemplateModule::balance_count(1, 1), 3000);210        assert_eq!(TemplateModule::balance_count(1, 1), 3000);
14711416
1472        assert_noop!(1417        assert_noop!(
1473            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1418            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),
1474            "Public minting is not allowed for this collection."1419            "Public minting is not allowed for this collection"
1475        );1420        );
1476    });1421    });
1477}1422}
15001445
1501        assert_noop!(1446        assert_noop!(
1502            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),1447            TemplateModule::create_item(origin2.clone(), 1, 2, default_nft_data().into()),
1503            "Public minting is not allowed for this collection."1448            "Public minting is not allowed for this collection"
1504        );1449        );
1505    });1450    });
1506}1451}