git.delta.rocks / unique-network / refs/commits / 51e66acd38a2

difftreelog

Merge branch 'develop' into feature/CORE-189

Igor Kozyrev2021-09-09parents: #2e92a20 #e873ca1.patch.diff
in: master

9 files changed

modifiednode/cli/src/chain_spec.rsdiffbeforeafterboth
196					const_on_chain_schema: vec![],196					const_on_chain_schema: vec![],
197					variable_on_chain_schema: vec![],197					variable_on_chain_schema: vec![],
198					limits: CollectionLimits::default(),198					limits: CollectionLimits::default(),
199					meta_update_permission: MetaUpdatePermission::ItemOwner,
199					transfers_enabled: true,200					transfers_enabled: true,
200				},201				},
201			)],202			)],
modifiedpallets/nft/src/lib.rsdiffbeforeafterboth
43	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,43	OFFCHAIN_SCHEMA_LIMIT, MAX_TOKEN_PREFIX_LENGTH, MAX_COLLECTION_NAME_LENGTH,
44	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,44	MAX_COLLECTION_DESCRIPTION_LENGTH, AccessMode, Collection, CreateItemData, CollectionLimits,
45	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,45	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,
46	FungibleItemType, ReFungibleItemType,46	MetaUpdatePermission, FungibleItemType, ReFungibleItemType,
47};47};
4848
49#[cfg(test)]49#[cfg(test)]
145		BadCreateRefungibleCall,145		BadCreateRefungibleCall,
146		/// Gas limit exceeded146		/// Gas limit exceeded
147		OutOfGas,147		OutOfGas,
148		/// Metadata update denied by collection settings
149		MetadataUpdateDenied,
150		/// Metadata update flag become unmutable with None option
151		MetadataFlagFrozen,
148		/// Collection settings not allowing items transferring152		/// Collection settings not allowing items transferring
149		TransferNotAllowed,153		TransferNotAllowed,
150		/// Can't transfer tokens to ethereum zero address154		/// Can't transfer tokens to ethereum zero address
541				variable_on_chain_schema: Vec::new(),545				variable_on_chain_schema: Vec::new(),
542				const_on_chain_schema: Vec::new(),546				const_on_chain_schema: Vec::new(),
543				limits,547				limits,
548				meta_update_permission: MetaUpdatePermission::default(),
544				transfers_enabled: true,549				transfers_enabled: true,
545			};550			};
546551
940			target_collection.save()945			target_collection.save()
941		}946		}
947
948		// TODO! transaction weight
949		/// Set meta_update_permission value for particular collection
950		///
951		/// # Permissions
952		///
953		/// * Collection Owner.
954		///
955		/// # Arguments
956		///
957		/// * collection_id: ID of the collection.
958		///
959		/// * value: New flag value.
960		#[weight = <T as Config>::WeightInfo::burn_item()]
961		#[transactional]
962		pub fn set_meta_update_permission_flag(origin, collection_id: CollectionId, value: MetaUpdatePermission) -> DispatchResult {
963
964			let sender = ensure_signed(origin)?;
965			let mut target_collection = Self::get_collection(collection_id)?;
966
967			ensure!(
968				target_collection.meta_update_permission != MetaUpdatePermission::None,
969				Error::<T>::MetadataFlagFrozen
970			);
971			Self::check_owner_permissions(&target_collection, &sender)?;
972
973			target_collection.meta_update_permission = value;
974
975			target_collection.save()
976		}
942977
943		/// Destroys a concrete instance of NFT.978		/// Destroys a concrete instance of NFT.
944		///979		///
1485			Error::<T>::TokenVariableDataLimitExceeded1520			Error::<T>::TokenVariableDataLimitExceeded
1486		);1521		);
14871522
1488		// Modify permissions check
1489		ensure!(1523		ensure!(
1490			Self::is_item_owner(sender, collection, item_id)?1524			(Self::is_item_owner(sender, collection, item_id)?
1525				&& collection.meta_update_permission == MetaUpdatePermission::ItemOwner)
1491				|| Self::is_owner_or_admin_permissions(collection, sender)?,1526				|| (Self::is_owner_or_admin_permissions(collection, sender)?
1527					&& collection.meta_update_permission == MetaUpdatePermission::Admin),
1492			Error::<T>::NoPermission1528			Error::<T>::NoPermission
1493		);1529		);
14941530
1504		Ok(())1540		Ok(())
1505	}1541	}
1542
1543	pub fn meta_update_check(
1544		sender: &T::CrossAccountId,
1545		collection: &CollectionHandle<T>,
1546		item_id: TokenId,
1547	) -> DispatchResult {
1548		match collection.meta_update_permission {
1549			MetaUpdatePermission::ItemOwner => ensure!(
1550				Self::is_item_owner(sender, collection, item_id)?,
1551				Error::<T>::NoPermission
1552			),
1553			MetaUpdatePermission::Admin => ensure!(
1554				Self::is_owner_or_admin_permissions(collection, sender)?,
1555				Error::<T>::NoPermission
1556			),
1557			MetaUpdatePermission::None => fail!(Error::<T>::MetadataUpdateDenied),
1558		}
1559
1560		Ok(())
1561	}
15061562
1507	pub fn get_variable_metadata(1563	pub fn get_variable_metadata(
1508		collection: &CollectionHandle<T>,1564		collection: &CollectionHandle<T>,
modifiedpallets/nft/src/tests.rsdiffbeforeafterboth
2004	});2004	});
2005}2005}
2006
2007#[test]
2008fn set_variable_meta_data_on_nft_with_item_owner_permission_flag() {
2009	new_test_ext().execute_with(|| {
2010		//default_limits();
2011
2012		let collection_id = create_test_collection(&CollectionMode::NFT, 1);
2013
2014		let origin1 = Origin::signed(1);
2015
2016		let data = default_nft_data();
2017		create_test_item(1, &data.into());
2018
2019		TemplateModule::set_meta_update_permission_flag(
2020			origin1.clone(),
2021			collection_id,
2022			MetaUpdatePermission::ItemOwner,
2023		);
2024
2025		let variable_data = b"ten chars.".to_vec();
2026		assert_ok!(TemplateModule::set_variable_meta_data(
2027			origin1,
2028			collection_id,
2029			1,
2030			variable_data.clone()
2031		));
2032
2033		assert_eq!(
2034			TemplateModule::nft_item_id(collection_id, 1)
2035				.unwrap()
2036				.variable_data,
2037			variable_data
2038		);
2039	});
2040}
2041
2042#[test]
2043fn set_variable_meta_data_on_nft_with_item_owner_permission_flag_neg() {
2044	new_test_ext().execute_with(|| {
2045		// default_limits();
2046
2047		let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1);
2048
2049		let origin1 = Origin::signed(1);
2050		let origin2 = Origin::signed(2);
2051
2052		assert_ok!(TemplateModule::set_mint_permission(
2053			origin2.clone(),
2054			collection_id,
2055			true
2056		));
2057		assert_ok!(TemplateModule::add_to_white_list(
2058			origin2.clone(),
2059			collection_id,
2060			account(1)
2061		));
2062
2063		let data = default_nft_data();
2064		create_test_item(1, &data.into());
2065
2066		assert_ok!(TemplateModule::set_meta_update_permission_flag(
2067			origin2.clone(),
2068			collection_id,
2069			MetaUpdatePermission::ItemOwner,
2070		));
2071
2072		let variable_data = b"ten chars.++".to_vec();
2073		assert_noop!(
2074			TemplateModule::set_variable_meta_data(
2075				origin2,
2076				collection_id,
2077				1,
2078				variable_data.clone()
2079			),
2080			Error::<Test>::TokenVariableDataLimitExceeded
2081		);
20062082
2007#[test]2083		#[test]
2008fn collection_transfer_flag_works() {2084		fn collection_transfer_flag_works() {
2029	});2105			});
2030}2106		}
2107
2108		#[test]
2109		fn set_variable_meta_data_on_nft_with_admin_flag() {
2110			new_test_ext().execute_with(|| {
2111				// default_limits();
2112
2113				let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1);
2114
2115				let origin1 = Origin::signed(1);
2116				let origin2 = Origin::signed(2);
2117
2118				assert_ok!(TemplateModule::set_mint_permission(
2119					origin2.clone(),
2120					collection_id,
2121					true
2122				));
2123				assert_ok!(TemplateModule::add_to_white_list(
2124					origin2.clone(),
2125					collection_id,
2126					account(1)
2127				));
2128
2129				assert_ok!(TemplateModule::add_collection_admin(
2130					origin2.clone(),
2131					collection_id,
2132					account(1)
2133				));
2134
2135				let data = default_nft_data();
2136				create_test_item(1, &data.into());
2137
2138				assert_ok!(TemplateModule::set_meta_update_permission_flag(
2139					origin2.clone(),
2140					collection_id,
2141					MetaUpdatePermission::Admin,
2142				));
2143
2144				let variable_data = b"test set_variable_meta_data method.".to_vec();
2145				assert_ok!(TemplateModule::set_variable_meta_data(
2146					origin1,
2147					collection_id,
2148					1,
2149					variable_data.clone()
2150				));
2151
2152				assert_eq!(
2153					TemplateModule::nft_item_id(collection_id, 1)
2154						.unwrap()
2155						.variable_data,
2156					variable_data
2157				);
2158			});
2159		}
2160
2161		#[test]
2162		fn set_variable_meta_data_on_nft_with_admin_flag_neg() {
2163			new_test_ext().execute_with(|| {
2164				// default_limits();
2165
2166				let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1);
2167
2168				let origin1 = Origin::signed(1);
2169				let origin2 = Origin::signed(2);
2170
2171				assert_ok!(TemplateModule::set_mint_permission(
2172					origin2.clone(),
2173					collection_id,
2174					true
2175				));
2176				assert_ok!(TemplateModule::add_to_white_list(
2177					origin2.clone(),
2178					collection_id,
2179					account(1)
2180				));
2181
2182				let data = default_nft_data();
2183				create_test_item(1, &data.into());
2184
2185				assert_ok!(TemplateModule::set_meta_update_permission_flag(
2186					origin2.clone(),
2187					collection_id,
2188					MetaUpdatePermission::Admin,
2189				));
2190
2191				let variable_data = b"test set_variable_meta_data method.".to_vec();
2192				assert_noop!(
2193					TemplateModule::set_variable_meta_data(
2194						origin1,
2195						collection_id,
2196						1,
2197						variable_data.clone()
2198					),
2199					Error::<Test>::NoPermission
2200				);
2201			});
2202		}
2203
2204		#[test]
2205		fn set_variable_meta_flag_after_freeze() {
2206			new_test_ext().execute_with(|| {
2207				// default_limits();
2208
2209				let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 2, 1);
2210
2211				let origin2 = Origin::signed(2);
2212
2213				assert_ok!(TemplateModule::set_meta_update_permission_flag(
2214					origin2.clone(),
2215					collection_id,
2216					MetaUpdatePermission::None,
2217				));
2218				assert_noop!(
2219					TemplateModule::set_meta_update_permission_flag(
2220						origin2.clone(),
2221						collection_id,
2222						MetaUpdatePermission::Admin
2223					),
2224					Error::<Test>::MetadataFlagFrozen
2225				);
2226			});
2227		}
2228
2229		#[test]
2230		fn set_variable_meta_data_on_nft_with_none_flag_neg() {
2231			new_test_ext().execute_with(|| {
2232				// default_limits();
2233
2234				let collection_id = create_test_collection_for_owner(&CollectionMode::NFT, 1, 1);
2235				let origin1 = Origin::signed(1);
2236
2237				let data = default_nft_data();
2238				create_test_item(1, &data.into());
2239
2240				assert_ok!(TemplateModule::set_meta_update_permission_flag(
2241					origin1.clone(),
2242					collection_id,
2243					MetaUpdatePermission::None,
2244				));
2245
2246				let variable_data = b"test set_variable_meta_data method.".to_vec();
2247				assert_noop!(
2248					TemplateModule::set_variable_meta_data(
2249						origin1.clone(),
2250						collection_id,
2251						1,
2252						variable_data.clone()
2253					),
2254					Error::<Test>::MetadataUpdateDenied
2255				);
2256			});
2257		}
20312258
2032#[test]2259		#[test]
2033fn collection_transfer_flag_works_neg() {2260		fn collection_transfer_flag_works_neg() {
2058		assert_eq!(TemplateModule::address_tokens(1, 1), [1]);2285				assert_eq!(TemplateModule::address_tokens(1, 1), [1]);
2059	});2286			});
2060}2287		}
2288	});
2289}
20612290
modifiedprimitives/nft/src/lib.rsdiffbeforeafterboth
185	pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions185	pub limits: CollectionLimits<T::BlockNumber>, // Collection private restrictions
186	pub variable_on_chain_schema: Vec<u8>,        //186	pub variable_on_chain_schema: Vec<u8>,        //
187	pub const_on_chain_schema: Vec<u8>,           //187	pub const_on_chain_schema: Vec<u8>,           //
188	pub meta_update_permission: MetaUpdatePermission,
188	pub transfers_enabled: bool,189	pub transfers_enabled: bool,
189}190}
190191
305	pub pieces: u128,306	pub pieces: u128,
306}307}
308
309#[derive(Encode, Decode, Debug, Clone, PartialEq)]
310#[cfg_attr(feature = "std", derive(Serialize, Deserialize))]
311pub enum MetaUpdatePermission {
312	ItemOwner,
313	Admin,
314	None,
315}
316
317impl Default for MetaUpdatePermission {
318	fn default() -> Self {
319		Self::ItemOwner
320	}
321}
307322
308#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug)]323#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug)]
309#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]324#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
modifiedruntime_types.jsondiffbeforeafterboth
63      "Limits": "CollectionLimits",63      "Limits": "CollectionLimits",
64      "VariableOnChainSchema": "Vec<u8>",64      "VariableOnChainSchema": "Vec<u8>",
65      "ConstOnChainSchema": "Vec<u8>",65      "ConstOnChainSchema": "Vec<u8>",
66      "MetaUpdatePermission": "MetaUpdatePermission",
66      "TransfersEnabled": "bool"67      "TransfersEnabled": "bool"
67    },68    },
68    "RawData": "Vec<u8>",69    "RawData": "Vec<u8>",
94        "Unique"95        "Unique"
95      ]96      ]
96    },97    },
98    "MetaUpdatePermission": {
99      "_enum": [
100        "ItemOwner",
101        "Admin",
102        "None"      
103      ]
104    },
97    "CollectionId": "u32",105    "CollectionId": "u32",
98    "TokenId": "u32",106    "TokenId": "u32",
99    "ChainLimits": {107    "ChainLimits": {
modifiedtests/src/addCollectionAdmin.test.tsdiffbeforeafterboth
4//4//
55
6import { ApiPromise } from '@polkadot/api';6import { ApiPromise } from '@polkadot/api';
7import BN from 'bn.js';
8import chai from 'chai';7import chai from 'chai';
9import chaiAsPromised from 'chai-as-promised';8import chaiAsPromised from 'chai-as-promised';
10import privateKey from './substrate/privateKey';9import privateKey from './substrate/privateKey';
modifiedtests/src/collision-tests/adminLimitsOff.test.tsdiffbeforeafterboth
1import { IKeyringPair } from '@polkadot/types/types';1import { IKeyringPair } from '@polkadot/types/types';
2import BN from 'bn.js';
3import chai from 'chai';2import chai from 'chai';
4import chaiAsPromised from 'chai-as-promised';3import chaiAsPromised from 'chai-as-promised';
5import privateKey from '../substrate/privateKey';4import privateKey from '../substrate/privateKey';
addedtests/src/metadataUpdate.test.tsdiffbeforeafterboth

no changes

modifiedtests/src/util/helpers.tsdiffbeforeafterboth
525  });525  });
526}526}
527
528export async function setMetadataUpdatePermissionFlagExpectSuccess(sender: IKeyringPair, collectionId: number, flag: string) {
529
530  await usingApi(async (api) => {
531    const tx = api.tx.nft.setMetaUpdatePermissionFlag(collectionId, flag); 
532    const events = await submitTransactionAsync(sender, tx);
533    const result = getGenericResult(events);
534
535    expect(result.success).to.be.true;
536  }); 
537}
538
539export async function setMetadataUpdatePermissionFlagExpectFailure(sender: IKeyringPair, collectionId: number, flag: string) {
540
541  await usingApi(async (api) => {
542    const tx = api.tx.nft.setMetaUpdatePermissionFlag(collectionId, flag); 
543    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;
544    const result = getGenericResult(events);
545
546    expect(result.success).to.be.false;
547  }); 
548}
527549
528export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {550export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {
529  await usingApi(async (api) => {551  await usingApi(async (api) => {