git.delta.rocks / unique-network / refs/commits / bba462e4a170

1{1{
2	"name": "Rust",2	"name": "Rust",
3    "dockerComposeFile": "./docker-compose.yml",3    "dockerComposeFile": "./docker-compose.yml",
4    "service": "nft_private",4    "service": "unique-chain",
5    "workspaceFolder": "/workspaces/nft_private",5    "workspaceFolder": "/workspaces/unique-chain",
6	"settings": { 6	"settings": { 
7		"terminal.integrated.shell.linux": "/bin/bash",7		"terminal.integrated.shell.linux": "/bin/bash",
8		"lldb.executable": "/usr/bin/lldb",8		"lldb.executable": "/usr/bin/lldb",

1version: '3'1version: '3'
2services:2services:
3  nft_private:3  unique-chain:
4    build: 4    build: 
5        context: .5        context: .
6    environment:6    environment:
7      - JAEGER_AGENT_HOST=jaeger7      - JAEGER_AGENT_HOST=jaeger
8      - JAEGER_AGENT_PORT=68318      - JAEGER_AGENT_PORT=6831
9    volumes:9    volumes:
10      - ..:/workspaces/nft_private:cached10      - ..:/workspaces/unique-chain:cached
11      - ../../polkadot:/workspaces/polkadot:cached11      - ../../polkadot:/workspaces/polkadot:cached
12      - ../../polkadot-launch:/workspaces/polkadot-launch:cached12      - ../../polkadot-launch:/workspaces/polkadot-launch:cached
13      #- ../../frontier:/workspaces/frontier13      #- ../../frontier:/workspaces/frontier

32          key: ${{ secrets.KEY }}32          key: ${{ secrets.KEY }}
33          port: ${{ secrets.SERVER_PORT }}33          port: ${{ secrets.SERVER_PORT }}
34          command_timeout: 300m34          command_timeout: 300m
35          script: |35          script: |
36            eval $(ssh-agent -s)36            eval $(ssh-agent -s)
37            ssh-add /home/devops/.ssh/git_hub37            ssh-add /home/devops/.ssh/git_hub
38            git clone git@github.com:UniqueNetwork/nft_private.git38            git clone git@github.com:UniqueNetwork/unique-chain.git
39            cd nft_private39            cd unique-chain
40            git checkout develop40            git checkout develop
41            # git pull --all41            # git pull --all
42            chmod +x ci_node.sh42            chmod +x ci_node.sh
43            ./ci_node.sh43            ./ci_node.sh
44            rm -rf /home/polkadot/nft_private44            rm -rf /home/polkadot/unique-chain
4545

98    npm install --global yarn && \98    npm install --global yarn && \
99    yarn99    yarn
100100
101COPY --from=builder /nft_parachain/target/$PROFILE/nft /nft_private/target/$PROFILE/101COPY --from=builder /nft_parachain/target/$PROFILE/nft /unique-chain/target/$PROFILE/
102COPY --from=builder-polkadot /nft_parachain/polkadot/target/$PROFILE/polkadot /polkadot/target/$PROFILE/102COPY --from=builder-polkadot /nft_parachain/polkadot/target/$PROFILE/polkadot /polkadot/target/$PROFILE/
103103
104CMD export NVM_DIR="$HOME/.nvm" && \104CMD export NVM_DIR="$HOME/.nvm" && \

3use codec::Decode;3use codec::Decode;
4use jsonrpc_core::{Error as RpcError, ErrorCode, Result};4use jsonrpc_core::{Error as RpcError, ErrorCode, Result};
5use jsonrpc_derive::rpc;5use jsonrpc_derive::rpc;
6use nft_data_structs::{CollectionId, TokenId};6use nft_data_structs::{Collection, CollectionId, CollectionStats, TokenId};
7use sp_api::{BlockId, BlockT, ProvideRuntimeApi};7use sp_api::{BlockId, BlockT, ProvideRuntimeApi};
8use sp_blockchain::HeaderBackend;8use sp_blockchain::HeaderBackend;
9use up_rpc::NftApi as NftRuntimeApi;9use up_rpc::NftApi as NftRuntimeApi;
86		collection: CollectionId,86		collection: CollectionId,
87		at: Option<BlockHash>,87		at: Option<BlockHash>,
88	) -> Result<Vec<CrossAccountId>>;88	) -> Result<Vec<CrossAccountId>>;
89	#[rpc(name = "nft_allowed")]
90	fn allowed(
91		&self,
92		collection: CollectionId,
93		user: CrossAccountId,
94		at: Option<BlockHash>,
95	) -> Result<bool>;
89	#[rpc(name = "nft_lastTokenId")]96	#[rpc(name = "nft_lastTokenId")]
90	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;97	fn last_token_id(&self, collection: CollectionId, at: Option<BlockHash>) -> Result<TokenId>;
98	#[rpc(name = "nft_collectionById")]
99	fn collection_by_id(
100		&self,
101		collection: CollectionId,
102		at: Option<BlockHash>,
103	) -> Result<Option<Collection<AccountId>>>;
104	#[rpc(name = "nft_collectionStats")]
105	fn collection_stats(&self, at: Option<BlockHash>) -> Result<CollectionStats>;
91}106}
92107
93pub struct Nft<C, P> {108pub struct Nft<C, P> {
160175
161	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>);176	pass_method!(adminlist(collection: CollectionId) -> Vec<CrossAccountId>);
162	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>);177	pass_method!(allowlist(collection: CollectionId) -> Vec<CrossAccountId>);
178	pass_method!(allowed(collection: CollectionId, user: CrossAccountId) -> bool);
163	pass_method!(last_token_id(collection: CollectionId) -> TokenId);179	pass_method!(last_token_id(collection: CollectionId) -> TokenId);
180	pass_method!(collection_by_id(collection: CollectionId) -> Option<Collection<AccountId>>);
181	pass_method!(collection_stats() -> CollectionStats);
164}182}
165183

55    },55    },
56    "parachains": [56    "parachains": [
57        {57        {
58            "bin": "../nft_private/target/release/nft",58            "bin": "../unique-chain/target/release/nft",
59            "id": "2000",59            "id": "2000",
60            "balance": "1000000000000000000000",60            "balance": "1000000000000000000000",
61            "nodes": [61            "nodes": [

19pub fn create_collection_raw<T: Config, R>(19pub fn create_collection_raw<T: Config, R>(
20	owner: T::AccountId,20	owner: T::AccountId,
21	mode: CollectionMode,21	mode: CollectionMode,
22	handler: impl FnOnce(Collection<T>) -> Result<CollectionId, DispatchError>,22	handler: impl FnOnce(Collection<T::AccountId>) -> Result<CollectionId, DispatchError>,
23	cast: impl FnOnce(CollectionHandle<T>) -> R,23	cast: impl FnOnce(CollectionHandle<T>) -> R,
24) -> Result<R, DispatchError> {24) -> Result<R, DispatchError> {
25	T::Currency::deposit_creating(&owner, T::CollectionCreationPrice::get());25	T::Currency::deposit_creating(&owner, T::CollectionCreationPrice::get());

12	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, ExistenceRequirement,12	COLLECTION_NUMBER_LIMIT, Collection, CollectionId, CreateItemData, ExistenceRequirement,
13	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH,13	MAX_COLLECTION_DESCRIPTION_LENGTH, MAX_COLLECTION_NAME_LENGTH, MAX_TOKEN_PREFIX_LENGTH,
14	COLLECTION_ADMINS_LIMIT, MetaUpdatePermission, Pays, PostDispatchInfo, TokenId, Weight,14	COLLECTION_ADMINS_LIMIT, MetaUpdatePermission, Pays, PostDispatchInfo, TokenId, Weight,
15	WithdrawReasons,15	WithdrawReasons, CollectionStats,
16};16};
17pub use pallet::*;17pub use pallet::*;
18use sp_core::H160;18use sp_core::H160;
26#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]26#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]
27pub struct CollectionHandle<T: Config> {27pub struct CollectionHandle<T: Config> {
28	pub id: CollectionId,28	pub id: CollectionId,
29	collection: Collection<T>,29	collection: Collection<T::AccountId>,
30	pub recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,30	pub recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,
31}31}
32impl<T: Config> CollectionHandle<T> {32impl<T: Config> CollectionHandle<T> {
78	}78	}
79}79}
80impl<T: Config> Deref for CollectionHandle<T> {80impl<T: Config> Deref for CollectionHandle<T> {
81	type Target = Collection<T>;81	type Target = Collection<T::AccountId>;
8282
83	fn deref(&self) -> &Self::Target {83	fn deref(&self) -> &Self::Target {
84		&self.collection84		&self.collection
311	pub type CollectionById<T> = StorageMap<311	pub type CollectionById<T> = StorageMap<
312		Hasher = Blake2_128Concat,312		Hasher = Blake2_128Concat,
313		Key = CollectionId,313		Key = CollectionId,
314		Value = Collection<T>,314		Value = Collection<<T as frame_system::Config>::AccountId>,
315		QueryKind = OptionQuery,315		QueryKind = OptionQuery,
316	>;316	>;
317317
345		QueryKind = ValueQuery,345		QueryKind = ValueQuery,
346	>;346	>;
347
348	/// Not used by code, exists only to provide some types to metadata
349	#[pallet::storage]
350	pub type DummyStorageValue<T> =
351		StorageValue<Value = (CollectionStats, CollectionId, TokenId), QueryKind = OptionQuery>;
347}352}
348353
349impl<T: Config> Pallet<T> {354impl<T: Config> Pallet<T> {
355		);360		);
356		Ok(())361		Ok(())
357	}362	}
363	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {
364		<IsAdmin<T>>::iter_prefix((collection,))
365			.map(|(a, _)| a)
366			.collect()
367	}
368	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {
369		<Allowlist<T>>::iter_prefix((collection,))
370			.map(|(a, _)| a)
371			.collect()
372	}
373	pub fn allowed(collection: CollectionId, user: T::CrossAccountId) -> bool {
374		<Allowlist<T>>::get((collection, user))
375	}
376	pub fn collection_stats() -> CollectionStats {
377		let created = <CreatedCollectionCount<T>>::get();
378		let destroyed = <DestroyedCollectionCount<T>>::get();
379		CollectionStats {
380			created: created.0,
381			destroyed: destroyed.0,
382			alive: created.0 - destroyed.0,
383		}
384	}
358}385}
359386
360impl<T: Config> Pallet<T> {387impl<T: Config> Pallet<T> {
361	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {388	pub fn init_collection(data: Collection<T::AccountId>) -> Result<CollectionId, DispatchError> {
362		{389		{
363			ensure!(390			ensure!(
364				data.name.len() <= MAX_COLLECTION_NAME_LENGTH,391				data.name.len() <= MAX_COLLECTION_NAME_LENGTH,

91}91}
9292
93impl<T: Config> Pallet<T> {93impl<T: Config> Pallet<T> {
94	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {94	pub fn init_collection(data: Collection<T::AccountId>) -> Result<CollectionId, DispatchError> {
95		PalletCommon::init_collection(data)95		<PalletCommon<T>>::init_collection(data)
96	}96	}
97	pub fn destroy_collection(97	pub fn destroy_collection(
98		collection: FungibleHandle<T>,98		collection: FungibleHandle<T>,

42	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, MetaUpdatePermission,42	CollectionId, CollectionMode, TokenId, SchemaVersion, SponsorshipState, MetaUpdatePermission,
43};43};
44use pallet_common::{44use pallet_common::{
45	account::CrossAccountId, CollectionHandle, IsAdmin, Pallet as PalletCommon,45	account::CrossAccountId, CollectionHandle, Pallet as PalletCommon, Error as CommonError,
46	Error as CommonError, CommonWeightInfo, Allowlist,46	CommonWeightInfo,
47};47};
48use pallet_refungible::{Pallet as PalletRefungible, RefungibleHandle};48use pallet_refungible::{Pallet as PalletRefungible, RefungibleHandle};
49use pallet_fungible::{Pallet as PalletFungible, FungibleHandle};49use pallet_fungible::{Pallet as PalletFungible, FungibleHandle};
194			let who = ensure_signed(origin)?;194			let who = ensure_signed(origin)?;
195195
196			// Create new collection196			// Create new collection
197			let new_collection = Collection::<T> {197			let new_collection = Collection {
198				owner: who.clone(),198				owner: who.clone(),
199				name: collection_name,199				name: collection_name,
200				mode: mode.clone(),200				mode: mode.clone(),
212			};212			};
213213
214			let _id = match mode {214			let _id = match mode {
215				CollectionMode::NFT => {PalletNonfungible::init_collection(new_collection)?},215				CollectionMode::NFT => {<PalletNonfungible<T>>::init_collection(new_collection)?},
216				CollectionMode::Fungible(decimal_points) => {216				CollectionMode::Fungible(decimal_points) => {
217					// check params217					// check params
218					ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);218					ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);
219					PalletFungible::init_collection(new_collection)?219					<PalletFungible<T>>::init_collection(new_collection)?
220				}220				}
221				CollectionMode::ReFungible => {221				CollectionMode::ReFungible => {
222					PalletRefungible::init_collection(new_collection)?222					<PalletRefungible<T>>::init_collection(new_collection)?
223				}223				}
224			};224			};
225225
954	}954	}
955}955}
956
957// TODO: limit returned entries?
958impl<T: Config> Pallet<T> {
959	pub fn adminlist(collection: CollectionId) -> Vec<T::CrossAccountId> {
960		<IsAdmin<T>>::iter_prefix((collection,))
961			.map(|(a, _)| a)
962			.collect()
963	}
964	pub fn allowlist(collection: CollectionId) -> Vec<T::CrossAccountId> {
965		<Allowlist<T>>::iter_prefix((collection,))
966			.map(|(a, _)| a)
967			.collect()
968	}
969}
970956

133133
134// unchecked calls skips any permission checks134// unchecked calls skips any permission checks
135impl<T: Config> Pallet<T> {135impl<T: Config> Pallet<T> {
136	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {136	pub fn init_collection(data: Collection<T::AccountId>) -> Result<CollectionId, DispatchError> {
137		PalletCommon::init_collection(data)137		<PalletCommon<T>>::init_collection(data)
138	}138	}
139	pub fn destroy_collection(139	pub fn destroy_collection(
140		collection: NonfungibleHandle<T>,140		collection: NonfungibleHandle<T>,

156156
157// unchecked calls skips any permission checks157// unchecked calls skips any permission checks
158impl<T: Config> Pallet<T> {158impl<T: Config> Pallet<T> {
159	pub fn init_collection(data: Collection<T>) -> Result<CollectionId, DispatchError> {159	pub fn init_collection(data: Collection<T::AccountId>) -> Result<CollectionId, DispatchError> {
160		PalletCommon::init_collection(data)160		<PalletCommon<T>>::init_collection(data)
161	}161	}
162	pub fn destroy_collection(162	pub fn destroy_collection(
163		collection: RefungibleHandle<T>,163		collection: RefungibleHandle<T>,

209209
210#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]210#[derive(Encode, Decode, Clone, PartialEq, TypeInfo)]
211#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]211#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
212pub struct Collection<T: frame_system::Config> {212pub struct Collection<AccountId> {
213	pub owner: T::AccountId,213	pub owner: AccountId,
214	pub mode: CollectionMode,214	pub mode: CollectionMode,
215	pub access: AccessMode,215	pub access: AccessMode,
216	pub name: Vec<u16>,        // 64 include null escape char216	pub name: Vec<u16>,        // 64 include null escape char
219	pub mint_mode: bool,219	pub mint_mode: bool,
220	pub offchain_schema: Vec<u8>,220	pub offchain_schema: Vec<u8>,
221	pub schema_version: SchemaVersion,221	pub schema_version: SchemaVersion,
222	pub sponsorship: SponsorshipState<T::AccountId>,222	pub sponsorship: SponsorshipState<AccountId>,
223	pub limits: CollectionLimits,          // Collection private restrictions223	pub limits: CollectionLimits,          // Collection private restrictions
224	pub variable_on_chain_schema: Vec<u8>, //224	pub variable_on_chain_schema: Vec<u8>, //
225	pub const_on_chain_schema: Vec<u8>,    //225	pub const_on_chain_schema: Vec<u8>,    //
425	}425	}
426}426}
427
428#[derive(Encode, Decode, MaxEncodedLen, PartialEq, Clone, Debug, TypeInfo)]
429#[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
430pub struct CollectionStats {
431	pub created: u32,
432	pub destroyed: u32,
433	pub alive: u32,
434}
427435

1#![cfg_attr(not(feature = "std"), no_std)]1#![cfg_attr(not(feature = "std"), no_std)]
22
3use nft_data_structs::{CollectionId, TokenId};3use nft_data_structs::{CollectionId, TokenId, Collection, CollectionStats};
4use sp_std::vec::Vec;4use sp_std::vec::Vec;
5use sp_core::H160;5use sp_core::H160;
6use codec::Decode;6use codec::Decode;
3232
33		fn adminlist(collection: CollectionId) -> Vec<CrossAccountId>;33		fn adminlist(collection: CollectionId) -> Vec<CrossAccountId>;
34		fn allowlist(collection: CollectionId) -> Vec<CrossAccountId>;34		fn allowlist(collection: CollectionId) -> Vec<CrossAccountId>;
35		fn allowed(collection: CollectionId, user: CrossAccountId) -> bool;
35		fn last_token_id(collection: CollectionId) -> TokenId;36		fn last_token_id(collection: CollectionId) -> TokenId;
37		fn collection_by_id(collection: CollectionId) -> Option<Collection<AccountId>>;
38		fn collection_stats() -> CollectionStats;
36	}39	}
37}40}
3841

1045				.or_else(|| <pallet_evm_contract_helpers::HelpersOnMethodCall<Self>>::get_code(&account))1045				.or_else(|| <pallet_evm_contract_helpers::HelpersOnMethodCall<Self>>::get_code(&account))
1046		}1046		}
1047		fn adminlist(collection: CollectionId) -> Vec<CrossAccountId> {1047		fn adminlist(collection: CollectionId) -> Vec<CrossAccountId> {
1048			<pallet_nft::Pallet<Runtime>>::adminlist(collection)1048			<pallet_common::Pallet<Runtime>>::adminlist(collection)
1049		}1049		}
1050		fn allowlist(collection: CollectionId) -> Vec<CrossAccountId> {1050		fn allowlist(collection: CollectionId) -> Vec<CrossAccountId> {
1051			<pallet_nft::Pallet<Runtime>>::allowlist(collection)1051			<pallet_common::Pallet<Runtime>>::allowlist(collection)
1052		}1052		}
1053		fn allowed(collection: CollectionId, user: CrossAccountId) -> bool {
1054			<pallet_common::Pallet<Runtime>>::allowed(collection, user)
1055		}
1053		fn last_token_id(collection: CollectionId) -> TokenId {1056		fn last_token_id(collection: CollectionId) -> TokenId {
1054			dispatch_nft_runtime!(collection.last_token_id())1057			dispatch_nft_runtime!(collection.last_token_id())
1055		}1058		}
1059		fn collection_by_id(collection: CollectionId) -> Option<Collection<AccountId>> {
1060			<pallet_common::CollectionById<Runtime>>::get(collection)
1061		}
1062		fn collection_stats() -> CollectionStats {
1063			<pallet_common::Pallet<Runtime>>::collection_stats()
1064		}
1056	}1065	}
10571066
1058	impl sp_api::Core<Block> for Runtime {1067	impl sp_api::Core<Block> for Runtime {

8import chaiAsPromised from 'chai-as-promised';8import chaiAsPromised from 'chai-as-promised';
9import privateKey from './substrate/privateKey';9import privateKey from './substrate/privateKey';
10import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';10import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
11import {addCollectionAdminExpectSuccess, createCollectionExpectSuccess, destroyCollectionExpectSuccess, getAdminList, normalizeAccountId} from './util/helpers';11import {addCollectionAdminExpectSuccess, createCollectionExpectSuccess, destroyCollectionExpectSuccess, getAdminList, normalizeAccountId, queryCollectionExpectSuccess} from './util/helpers';
1212
13chai.use(chaiAsPromised);13chai.use(chaiAsPromised);
14const expect = chai.expect;14const expect = chai.expect;
20      const alice = privateKey('//Alice');20      const alice = privateKey('//Alice');
21      const bob = privateKey('//Bob');21      const bob = privateKey('//Bob');
2222
23      const collection = (await api.query.common.collectionById(collectionId)).unwrap();23      const collection = await queryCollectionExpectSuccess(api, collectionId);
24      expect(collection.owner.toString()).to.be.equal(alice.address);24      expect(collection.owner.toString()).to.be.equal(alice.address);
2525
26      const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(bob.address));26      const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(bob.address));
38      const bob = privateKey('//Bob');38      const bob = privateKey('//Bob');
39      const charlie = privateKey('//CHARLIE');39      const charlie = privateKey('//CHARLIE');
4040
41      const collection = (await api.query.common.collectionById(collectionId)).unwrap();41      const collection = await queryCollectionExpectSuccess(api, collectionId);
42      expect(collection.owner.toString()).to.be.equal(alice.address);42      expect(collection.owner.toString()).to.be.equal(alice.address);
4343
44      const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(bob.address));44      const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(bob.address));

18  normalizeAccountId,18  normalizeAccountId,
19  addCollectionAdminExpectSuccess,19  addCollectionAdminExpectSuccess,
20  addToAllowListExpectFail,20  addToAllowListExpectFail,
21  getCreatedCollectionCount,
21} from './util/helpers';22} from './util/helpers';
2223
23chai.use(chaiAsPromised);24chai.use(chaiAsPromised);
55  it('Allow list an address in the collection that does not exist', async () => {56  it('Allow list an address in the collection that does not exist', async () => {
56    await usingApi(async (api) => {57    await usingApi(async (api) => {
57      // tslint:disable-next-line: no-bitwise58      // tslint:disable-next-line: no-bitwise
58      const collectionId = ((await api.query.common.createdCollectionCount()).toNumber()) + 1;59      const collectionId = await getCreatedCollectionCount(api) + 1;
59      const bob = privateKey('//Bob');60      const bob = privateKey('//Bob');
6061
61      const tx = api.tx.nft.addToAllowList(collectionId, normalizeAccountId(bob.address));62      const tx = api.tx.nft.addToAllowList(collectionId, normalizeAccountId(bob.address));

18  transferExpectSuccess,18  transferExpectSuccess,
19  addCollectionAdminExpectSuccess,19  addCollectionAdminExpectSuccess,
20  adminApproveFromExpectSuccess,20  adminApproveFromExpectSuccess,
21  getCreatedCollectionCount,
21  transferFromExpectSuccess,22  transferFromExpectSuccess,
22  transferFromExpectFail,23  transferFromExpectFail,
23} from './util/helpers';24} from './util/helpers';
411  it('Approve for a collection that does not exist', async () => {412  it('Approve for a collection that does not exist', async () => {
412    await usingApi(async (api: ApiPromise) => {413    await usingApi(async (api: ApiPromise) => {
413      // nft414      // nft
414      const nftCollectionCount = (await api.query.common.createdCollectionCount()).toNumber();415      const nftCollectionCount = await getCreatedCollectionCount(api);
415      await approveExpectFail(nftCollectionCount + 1, 1, alice, bob);416      await approveExpectFail(nftCollectionCount + 1, 1, alice, bob);
416      // fungible417      // fungible
417      const fungibleCollectionCount = (await api.query.common.createdCollectionCount()).toNumber();418      const fungibleCollectionCount = await getCreatedCollectionCount(api);
418      await approveExpectFail(fungibleCollectionCount + 1, 0, alice, bob);419      await approveExpectFail(fungibleCollectionCount + 1, 0, alice, bob);
419      // reFungible420      // reFungible
420      const reFungibleCollectionCount = (await api.query.common.createdCollectionCount()).toNumber();421      const reFungibleCollectionCount = await getCreatedCollectionCount(api);
421      await approveExpectFail(reFungibleCollectionCount + 1, 1, alice, bob);422      await approveExpectFail(reFungibleCollectionCount + 1, 1, alice, bob);
422    });423    });
423  });424  });

22  setMintPermissionExpectFailure,22  setMintPermissionExpectFailure,
23  destroyCollectionExpectFailure,23  destroyCollectionExpectFailure,
24  setPublicAccessModeExpectSuccess,24  setPublicAccessModeExpectSuccess,
25  queryCollectionExpectSuccess,
25} from './util/helpers';26} from './util/helpers';
2627
27chai.use(chaiAsPromised);28chai.use(chaiAsPromised);
34      const alice = privateKey('//Alice');35      const alice = privateKey('//Alice');
35      const bob = privateKey('//Bob');36      const bob = privateKey('//Bob');
3637
37      const collection = (await api.query.common.collectionById(collectionId)).unwrap();38      const collection =await queryCollectionExpectSuccess(api, collectionId);
38      expect(collection.owner.toString()).to.be.deep.eq(alice.address);39      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
3940
40      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);41      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
41      await submitTransactionAsync(alice, changeOwnerTx);42      await submitTransactionAsync(alice, changeOwnerTx);
4243
43      const collectionAfterOwnerChange = (await api.query.common.collectionById(collectionId)).unwrap();44      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
44      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);45      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
45    });46    });
46  });47  });
53      const alice = privateKey('//Alice');54      const alice = privateKey('//Alice');
54      const bob = privateKey('//Bob');55      const bob = privateKey('//Bob');
5556
56      const collection = (await api.query.common.collectionById(collectionId)).unwrap();57      const collection = await queryCollectionExpectSuccess(api, collectionId);
57      expect(collection.owner.toString()).to.be.deep.eq(alice.address);58      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
5859
59      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);60      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
62      const badChangeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, alice.address);63      const badChangeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, alice.address);
63      await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;64      await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;
6465
65      const collectionAfterOwnerChange = (await api.query.common.collectionById(collectionId)).unwrap();66      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
66      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);67      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
67    });68    });
68  });69  });
74      const bob = privateKey('//Bob');75      const bob = privateKey('//Bob');
75      const charlie = privateKey('//Charlie');76      const charlie = privateKey('//Charlie');
7677
77      const collection = (await api.query.common.collectionById(collectionId)).unwrap();78      const collection = await queryCollectionExpectSuccess(api, collectionId);
78      expect(collection.owner.toString()).to.be.deep.eq(alice.address);79      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
7980
80      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);81      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
81      await submitTransactionAsync(alice, changeOwnerTx);82      await submitTransactionAsync(alice, changeOwnerTx);
8283
83      const collectionAfterOwnerChange = (await api.query.common.collectionById(collectionId)).unwrap();84      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
84      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);85      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
8586
86      // After changing the owner of the collection, all privileged methods are available to the new owner87      // After changing the owner of the collection, all privileged methods are available to the new owner
118      const bob = privateKey('//Bob');119      const bob = privateKey('//Bob');
119      const charlie = privateKey('//Charlie');120      const charlie = privateKey('//Charlie');
120121
121      const collection = (await api.query.common.collectionById(collectionId)).unwrap();122      const collection = await queryCollectionExpectSuccess(api, collectionId);
122      expect(collection.owner.toString()).to.be.deep.eq(alice.address);123      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
123124
124      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);125      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
125      await submitTransactionAsync(alice, changeOwnerTx);126      await submitTransactionAsync(alice, changeOwnerTx);
126127
127      const collectionAfterOwnerChange = (await api.query.common.collectionById(collectionId)).unwrap();128      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
128      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);129      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
129130
130      const changeOwnerTx2 = api.tx.nft.changeCollectionOwner(collectionId, charlie.address);131      const changeOwnerTx2 = api.tx.nft.changeCollectionOwner(collectionId, charlie.address);
131      await submitTransactionAsync(bob, changeOwnerTx2);132      await submitTransactionAsync(bob, changeOwnerTx2);
132133
133      // ownership lost134      // ownership lost
134      const collectionAfterOwnerChange2 = (await api.query.common.collectionById(collectionId)).unwrap();135      const collectionAfterOwnerChange2 = await queryCollectionExpectSuccess(api, collectionId);
135      expect(collectionAfterOwnerChange2.owner.toString()).to.be.deep.eq(charlie.address);136      expect(collectionAfterOwnerChange2.owner.toString()).to.be.deep.eq(charlie.address);
136    });137    });
137  });138  });
147      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);148      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
148      await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;149      await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;
149150
150      const collectionAfterOwnerChange = (await api.query.common.collectionById(collectionId)).unwrap();151      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
151      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(alice.address);152      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(alice.address);
152153
153      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)154      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
166      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);167      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
167      await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;168      await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;
168169
169      const collectionAfterOwnerChange = (await api.query.common.collectionById(collectionId)).unwrap();170      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
170      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(alice.address);171      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(alice.address);
171172
172      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)173      // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
195      const bob = privateKey('//Bob');196      const bob = privateKey('//Bob');
196      const charlie = privateKey('//Charlie');197      const charlie = privateKey('//Charlie');
197198
198      const collection = (await api.query.common.collectionById(collectionId)).unwrap();199      const collection = await queryCollectionExpectSuccess(api, collectionId);
199      expect(collection.owner.toString()).to.be.deep.eq(alice.address);200      expect(collection.owner.toString()).to.be.deep.eq(alice.address);
200201
201      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);202      const changeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, bob.address);
204      const badChangeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, alice.address);205      const badChangeOwnerTx = api.tx.nft.changeCollectionOwner(collectionId, alice.address);
205      await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;206      await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;
206207
207      const collectionAfterOwnerChange = (await api.query.common.collectionById(collectionId)).unwrap();208      const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
208      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);209      expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
209210
210      await setCollectionSponsorExpectFailure(collectionId, charlie.address, '//Alice');211      await setCollectionSponsorExpectFailure(collectionId, charlie.address, '//Alice');