1import {expect} from 'chai';2import usingApi, {executeTransaction} from '../substrate/substrate-api';3import {4 addCollectionAdminExpectSuccess,5 createCollectionExpectSuccess,6 setCollectionPermissionsExpectSuccess,7 createItemExpectSuccess,8 getCreateCollectionResult,9 transferExpectSuccess,10} from '../util/helpers';11import {IKeyringPair} from '@polkadot/types/types';12import {tokenIdToAddress} from '../eth/util/helpers';1314let alice: IKeyringPair;15let bob: IKeyringPair;16let charlie: IKeyringPair;1718describe('Composite Properties Test', () => {19 before(async () => {20 await usingApi(async (api, privateKeyWrapper) => {21 alice = privateKeyWrapper('//Alice');22 bob = privateKeyWrapper('//Bob');23 });24 });2526 it('Makes sure collectionById supplies required fields', async () => {27 await usingApi(async api => {28 const collectionId = await createCollectionExpectSuccess();2930 const collectionOption = await api.rpc.unique.collectionById(collectionId);31 expect(collectionOption.isSome).to.be.true;32 let collection = collectionOption.unwrap();33 expect(collection.tokenPropertyPermissions.toHuman()).to.be.empty;34 expect(collection.properties.toHuman()).to.be.empty;3536 const propertyPermissions = [37 {key: 'mindgame', permission: {collectionAdmin: true, mutable: false, tokenOwner: true}},38 {key: 'skullduggery', permission: {collectionAdmin: false, mutable: true, tokenOwner: false}},39 ];40 await expect(executeTransaction(41 api, 42 alice, 43 api.tx.unique.setTokenPropertyPermissions(collectionId, propertyPermissions), 44 )).to.not.be.rejected;4546 const collectionProperties = [47 {key: 'black_hole', value: 'LIGO'},48 {key: 'electron', value: 'come bond'}, 49 ];50 await expect(executeTransaction(51 api, 52 alice, 53 api.tx.unique.setCollectionProperties(collectionId, collectionProperties), 54 )).to.not.be.rejected;5556 collection = (await api.rpc.unique.collectionById(collectionId)).unwrap();57 expect(collection.tokenPropertyPermissions.toHuman()).to.be.deep.equal(propertyPermissions);58 expect(collection.properties.toHuman()).to.be.deep.equal(collectionProperties);59 });60 });61});62636465describe('Integration Test: Collection Properties', () => {66 before(async () => {67 await usingApi(async (api, privateKeyWrapper) => {68 alice = privateKeyWrapper('//Alice');69 bob = privateKeyWrapper('//Bob');70 });71 });7273 it('Reads properties from a collection', async () => {74 await usingApi(async api => {75 const collection = await createCollectionExpectSuccess();76 const properties = (await api.query.common.collectionProperties(collection)).toJSON();77 expect(properties.map).to.be.empty;78 expect(properties.consumedSpace).to.equal(0);79 });80 });8182 it('Sets properties for a collection', async () => {83 await usingApi(async api => {84 const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: 'NFT'}));85 const {collectionId} = getCreateCollectionResult(events);8687 88 await expect(executeTransaction(89 api, 90 bob, 91 api.tx.unique.setCollectionProperties(collectionId, [{key: 'electron', value: 'come bond'}]), 92 )).to.not.be.rejected;9394 await addCollectionAdminExpectSuccess(bob, collectionId, alice.address);9596 97 await expect(executeTransaction(98 api, 99 alice, 100 api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 101 )).to.not.be.rejected;102103 const properties = (await api.rpc.unique.collectionProperties(collectionId, ['electron', 'black_hole'])).toHuman();104 expect(properties).to.be.deep.equal([105 {key: 'electron', value: 'come bond'},106 {key: 'black_hole', value: ''},107 ]);108 });109 });110111 it('Check valid names for collection properties keys', async () => {112 await usingApi(async api => {113 const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: 'NFT'}));114 const {collectionId} = getCreateCollectionResult(events);115116 117 await expect(executeTransaction(118 api, 119 bob, 120 api.tx.unique.setCollectionProperties(collectionId, [{key: 'alpha'}]), 121 )).to.not.be.rejected;122123 124 await expect(executeTransaction(125 api, 126 bob, 127 api.tx.unique.setCollectionProperties(collectionId, [{key: '123'}]), 128 )).to.not.be.rejected;129130 131 await expect(executeTransaction(132 api, 133 bob, 134 api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 135 )).to.not.be.rejected;136137 138 await expect(executeTransaction(139 api, 140 bob, 141 api.tx.unique.setCollectionProperties(collectionId, [{key: 'semi-automatic'}]), 142 )).to.not.be.rejected;143144 145 await expect(executeTransaction(146 api, 147 bob, 148 api.tx.unique.setCollectionProperties(collectionId, [{key: 'build.rs'}]), 149 )).to.not.be.rejected;150151 const propertyKeys = ['alpha', '123', 'black_hole', 'semi-automatic', 'build.rs'];152 const properties = (await api.rpc.unique.collectionProperties(collectionId, propertyKeys)).toHuman();153 expect(properties).to.be.deep.equal([154 {key: 'alpha', value: ''},155 {key: '123', value: ''},156 {key: 'black_hole', value: ''},157 {key: 'semi-automatic', value: ''},158 {key: 'build.rs', value: ''},159 ]);160 });161 });162163 it('Changes properties of a collection', async () => {164 await usingApi(async api => {165 const collection = await createCollectionExpectSuccess();166167 await expect(executeTransaction(168 api, 169 alice, 170 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole'}]), 171 )).to.not.be.rejected;172173 174 await expect(executeTransaction(175 api, 176 alice, 177 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'bonded'}, {key: 'black_hole', value: 'LIGO'}]), 178 )).to.not.be.rejected;179180 const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();181 expect(properties).to.be.deep.equal([182 {key: 'electron', value: 'bonded'},183 {key: 'black_hole', value: 'LIGO'},184 ]);185 });186 });187188 it('Deletes properties of a collection', async () => {189 await usingApi(async api => {190 const collection = await createCollectionExpectSuccess();191192 await expect(executeTransaction(193 api, 194 alice, 195 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 196 )).to.not.be.rejected;197198 await expect(executeTransaction(199 api, 200 alice, 201 api.tx.unique.deleteCollectionProperties(collection, ['electron']), 202 )).to.not.be.rejected;203204 const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();205 expect(properties).to.be.deep.equal([206 {key: 'black_hole', value: 'LIGO'},207 ]);208 });209 });210});211212describe('Negative Integration Test: Collection Properties', () => {213 before(async () => {214 await usingApi(async (api, privateKeyWrapper) => {215 alice = privateKeyWrapper('//Alice');216 bob = privateKeyWrapper('//Bob');217 });218 });219 220 it('Fails to set properties in a collection if not its onwer/administrator', async () => {221 await usingApi(async api => {222 const collection = await createCollectionExpectSuccess();223224 await expect(executeTransaction(225 api, 226 bob, 227 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 228 )).to.be.rejectedWith(/common\.NoPermission/);229 230 const properties = (await api.query.common.collectionProperties(collection)).toJSON();231 expect(properties.map).to.be.empty;232 expect(properties.consumedSpace).to.equal(0);233 });234 });235 236 it('Fails to set properties that exceed the limits', async () => {237 await usingApi(async api => {238 const collection = await createCollectionExpectSuccess();239 const spaceLimit = (await api.query.common.collectionProperties(collection)).toJSON().spaceLimit as number; 240241 242 {243 console.error = () => {};244 await expect(executeTransaction(245 api, 246 alice, 247 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))}]), 248 )).to.be.rejected;249 }250251 let properties = (await api.rpc.unique.collectionProperties(collection, ['electron'])).toJSON();252 expect(properties).to.be.empty;253254 await expect(executeTransaction(255 api, 256 alice, 257 api.tx.unique.setCollectionProperties(collection, [258 {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, 259 {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, 260 ]), 261 )).to.be.rejectedWith(/common\.NoSpaceForProperty/);262263 properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black hole'])).toJSON();264 expect(properties).to.be.empty;265 });266 });267 268 it('Fails to set more properties than it is allowed', async () => {269 await usingApi(async api => {270 const collection = await createCollectionExpectSuccess();271272 const propertiesToBeSet = [];273 for (let i = 0; i < 65; i++) {274 propertiesToBeSet.push({275 key: 'electron_' + i,276 value: Math.random() > 0.5 ? 'high' : 'low',277 });278 }279280 await expect(executeTransaction(281 api, 282 alice, 283 api.tx.unique.setCollectionProperties(collection, propertiesToBeSet), 284 )).to.be.rejectedWith(/common\.PropertyLimitReached/);285286 const properties = (await api.query.common.collectionProperties(collection)).toJSON();287 expect(properties.map).to.be.empty;288 expect(properties.consumedSpace).to.equal(0);289 });290 });291292 it('Fails to set properties with invalid names', async () => {293 await usingApi(async api => {294 const collection = await createCollectionExpectSuccess();295296 const invalidProperties = [297 [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],298 [{key: 'Mr/Sandman', value: 'Bring me a gene'}],299 [{key: 'déjà vu', value: 'hmm...'}],300 ];301302 for (let i = 0; i < invalidProperties.length; i++) {303 await expect(executeTransaction(304 api, 305 alice, 306 api.tx.unique.setCollectionProperties(collection, invalidProperties[i]), 307 ), `on rejecting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);308 }309310 await expect(executeTransaction(311 api, 312 alice, 313 api.tx.unique.setCollectionProperties(collection, [{key: '', value: 'nothing must not exist'}]), 314 ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);315316 await expect(executeTransaction(317 api, 318 alice, 319 api.tx.unique.setCollectionProperties(collection, [320 {key: 'CRISPR-Cas9', value: 'rewriting nature!'},321 ]), 322 ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;323324 const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');325326 const properties = (await api.rpc.unique.collectionProperties(collection, keys)).toHuman();327 expect(properties).to.be.deep.equal([328 {key: 'CRISPR-Cas9', value: 'rewriting nature!'},329 ]);330331 for (let i = 0; i < invalidProperties.length; i++) {332 await expect(executeTransaction(333 api, 334 alice, 335 api.tx.unique.deleteCollectionProperties(collection, invalidProperties[i].map(propertySet => propertySet.key)), 336 ), `on trying to delete the non-existent badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);337 }338 });339 });340});341342343344describe('Integration Test: Access Rights to Token Properties', () => {345 before(async () => {346 await usingApi(async (api, privateKeyWrapper) => {347 alice = privateKeyWrapper('//Alice');348 bob = privateKeyWrapper('//Bob');349 });350 });351 352 it('Reads access rights to properties of a collection', async () => {353 await usingApi(async api => {354 const collection = await createCollectionExpectSuccess();355 const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();356 expect(propertyRights).to.be.empty;357 });358 });359 360 it('Sets access rights to properties of a collection', async () => {361 await usingApi(async api => {362 const collection = await createCollectionExpectSuccess();363364 await expect(executeTransaction(365 api, 366 alice, 367 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true}}]), 368 )).to.not.be.rejected;369370 await addCollectionAdminExpectSuccess(alice, collection, bob.address);371372 await expect(executeTransaction(373 api, 374 alice, 375 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]), 376 )).to.not.be.rejected;377378 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery', 'mindgame'])).toHuman();379 expect(propertyRights).to.be.deep.equal([380 {key: 'skullduggery', permission: {'mutable': true, 'collectionAdmin': false, 'tokenOwner': false}},381 {key: 'mindgame', permission: {'mutable': false, 'collectionAdmin': true, 'tokenOwner': false}},382 ]);383 });384 });385 386 it('Changes access rights to properties of a collection', async () => {387 await usingApi(async api => {388 const collection = await createCollectionExpectSuccess();389390 await expect(executeTransaction(391 api, 392 alice, 393 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]), 394 )).to.not.be.rejected;395396 await expect(executeTransaction(397 api, 398 alice, 399 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 400 )).to.not.be.rejected;401402 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();403 expect(propertyRights).to.be.deep.equal([404 {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},405 ]);406 });407 });408});409410describe('Negative Integration Test: Access Rights to Token Properties', () => {411 before(async () => {412 await usingApi(async (api, privateKeyWrapper) => {413 alice = privateKeyWrapper('//Alice');414 bob = privateKeyWrapper('//Bob');415 });416 });417418 it('Prevents from setting access rights to properties of a collection if not an onwer/admin', async () => {419 await usingApi(async api => {420 const collection = await createCollectionExpectSuccess();421422 await expect(executeTransaction(423 api, 424 bob, 425 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]), 426 )).to.be.rejectedWith(/common\.NoPermission/);427428 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toJSON();429 expect(propertyRights).to.be.empty;430 });431 });432433 it('Prevents from adding too many possible properties', async () => {434 await usingApi(async api => {435 const collection = await createCollectionExpectSuccess();436437 const constitution = [];438 for (let i = 0; i < 65; i++) {439 constitution.push({440 key: 'property_' + i,441 permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},442 });443 }444445 await expect(executeTransaction(446 api, 447 alice, 448 api.tx.unique.setTokenPropertyPermissions(collection, constitution), 449 )).to.be.rejectedWith(/common\.PropertyLimitReached/);450451 const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();452 expect(propertyRights).to.be.empty;453 });454 });455456 it('Prevents access rights to be modified if constant', async () => {457 await usingApi(async api => {458 const collection = await createCollectionExpectSuccess();459460 await expect(executeTransaction(461 api, 462 alice, 463 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 464 )).to.not.be.rejected;465466 await expect(executeTransaction(467 api, 468 alice, 469 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {}}]), 470 )).to.be.rejectedWith(/common\.NoPermission/);471472 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();473 expect(propertyRights).to.deep.equal([474 {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},475 ]);476 });477 });478479 it('Prevents adding properties with invalid names', async () => {480 await usingApi(async api => {481 const collection = await createCollectionExpectSuccess();482483 const invalidProperties = [484 [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],485 [{key: 'G#4', permission: {tokenOwner: true}}],486 [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],487 ];488489 for (let i = 0; i < invalidProperties.length; i++) {490 await expect(executeTransaction(491 api, 492 alice, 493 api.tx.unique.setTokenPropertyPermissions(collection, invalidProperties[i]), 494 ), `on setting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);495 }496497 await expect(executeTransaction(498 api, 499 alice, 500 api.tx.unique.setTokenPropertyPermissions(collection, [{key: '', permission: {}}]), 501 ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);502503 const correctKey = '--0x03116e387820CA05'; 504 await expect(executeTransaction(505 api, 506 alice, 507 api.tx.unique.setTokenPropertyPermissions(collection, [508 {key: correctKey, permission: {collectionAdmin: true}},509 ]), 510 ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;511512 const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');513514 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, keys)).toHuman();515 expect(propertyRights).to.be.deep.equal([516 {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},517 ]);518 });519 });520});521522523524describe('Integration Test: Token Properties', () => {525 let collection: number;526 let token: number;527 let nestedToken: number;528 let permissions: {permission: any, signers: IKeyringPair[]}[];529530 before(async () => {531 await usingApi(async (api, privateKeyWrapper) => {532 alice = privateKeyWrapper('//Alice');533 bob = privateKeyWrapper('//Bob');534 charlie = privateKeyWrapper('//Charlie');535536 permissions = [537 {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},538 {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]},539 {permission: {mutable: true, tokenOwner: true}, signers: [charlie]},540 {permission: {mutable: false, tokenOwner: true}, signers: [charlie]},541 {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},542 {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},543 ];544 });545 });546547 beforeEach(async () => {548 await usingApi(async () => {549 collection = await createCollectionExpectSuccess();550 await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});551552 token = await createItemExpectSuccess(alice, collection, 'NFT');553 nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});554555 await addCollectionAdminExpectSuccess(alice, collection, bob.address);556 await transferExpectSuccess(collection, token, alice, charlie);557 });558 });559 560 it('Reads yet empty properties of a token', async () => {561 await usingApi(async api => {562 const collection = await createCollectionExpectSuccess();563 const token = await createItemExpectSuccess(alice, collection, 'NFT');564 565 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();566 expect(properties.map).to.be.empty;567 expect(properties.consumedSpace).to.be.equal(0);568569 const tokenData = (await api.rpc.unique.tokenData(collection, token, ['anything'])).toJSON().properties;570 expect(tokenData).to.be.empty;571 });572 });573574 it('Assigns properties to a token according to permissions', async () => {575 await usingApi(async api => {576 const propertyKeys: string[] = [];577 let i = 0;578 for (const permission of permissions) {579 for (const signer of permission.signers) {580 const key = i + '_' + signer.address;581 propertyKeys.push(key);582583 await expect(executeTransaction(584 api, 585 alice, 586 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 587 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;588589 await expect(executeTransaction(590 api, 591 signer, 592 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 593 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;594 }595596 i++;597 }598599 const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];600 const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];601 for (let i = 0; i < properties.length; i++) {602 expect(properties[i].value).to.be.equal('Serotonin increase');603 expect(tokensData[i].value).to.be.equal('Serotonin increase');604 }605 });606 });607608 it('Changes properties of a token according to permissions', async () => {609 await usingApi(async api => {610 const propertyKeys: string[] = [];611 let i = 0;612 for (const permission of permissions) {613 if (!permission.permission.mutable) continue;614 615 for (const signer of permission.signers) {616 const key = i + '_' + signer.address;617 propertyKeys.push(key);618619 await expect(executeTransaction(620 api, 621 alice, 622 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 623 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;624625 await expect(executeTransaction(626 api, 627 signer, 628 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 629 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;630631 await expect(executeTransaction(632 api, 633 signer, 634 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin stable'}]), 635 ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;636 }637638 i++;639 }640641 const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];642 const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];643 for (let i = 0; i < properties.length; i++) {644 expect(properties[i].value).to.be.equal('Serotonin stable');645 expect(tokensData[i].value).to.be.equal('Serotonin stable');646 }647 });648 });649650 it('Deletes properties of a token according to permissions', async () => {651 await usingApi(async api => {652 const propertyKeys: string[] = [];653 let i = 0;654655 for (const permission of permissions) {656 if (!permission.permission.mutable) continue;657 658 for (const signer of permission.signers) {659 const key = i + '_' + signer.address;660 propertyKeys.push(key);661662 await expect(executeTransaction(663 api, 664 alice, 665 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 666 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;667668 await expect(executeTransaction(669 api, 670 signer, 671 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 672 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;673674 await expect(executeTransaction(675 api, 676 signer, 677 api.tx.unique.deleteTokenProperties(collection, token, [key]), 678 ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;679 }680 681 i++;682 }683684 const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toJSON() as any[];685 expect(properties).to.be.empty;686 const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toJSON().properties as any[];687 expect(tokensData).to.be.empty;688 expect((await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace).to.be.equal(0);689 });690 });691692 it('Assigns properties to a nested token according to permissions', async () => {693 await usingApi(async api => {694 const propertyKeys: string[] = [];695 let i = 0;696 for (const permission of permissions) {697 for (const signer of permission.signers) {698 const key = i + '_' + signer.address;699 propertyKeys.push(key);700701 await expect(executeTransaction(702 api, 703 alice, 704 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 705 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;706707 await expect(executeTransaction(708 api, 709 signer, 710 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 711 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;712 }713714 i++;715 }716717 const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];718 const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];719 for (let i = 0; i < properties.length; i++) {720 expect(properties[i].value).to.be.equal('Serotonin increase');721 expect(tokensData[i].value).to.be.equal('Serotonin increase');722 }723 });724 });725726 it('Changes properties of a nested token according to permissions', async () => {727 await usingApi(async api => {728 const propertyKeys: string[] = [];729 let i = 0;730 for (const permission of permissions) {731 if (!permission.permission.mutable) continue;732 733 for (const signer of permission.signers) {734 const key = i + '_' + signer.address;735 propertyKeys.push(key);736737 await expect(executeTransaction(738 api, 739 alice, 740 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 741 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;742743 await expect(executeTransaction(744 api, 745 signer, 746 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 747 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;748749 await expect(executeTransaction(750 api, 751 signer, 752 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin stable'}]), 753 ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;754 }755756 i++;757 }758759 const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];760 const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];761 for (let i = 0; i < properties.length; i++) {762 expect(properties[i].value).to.be.equal('Serotonin stable');763 expect(tokensData[i].value).to.be.equal('Serotonin stable');764 }765 });766 });767768 it('Deletes properties of a nested token according to permissions', async () => {769 await usingApi(async api => {770 const propertyKeys: string[] = [];771 let i = 0;772773 for (const permission of permissions) {774 if (!permission.permission.mutable) continue;775 776 for (const signer of permission.signers) {777 const key = i + '_' + signer.address;778 propertyKeys.push(key);779780 await expect(executeTransaction(781 api, 782 alice, 783 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 784 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;785786 await expect(executeTransaction(787 api, 788 signer, 789 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 790 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;791792 await expect(executeTransaction(793 api, 794 signer, 795 api.tx.unique.deleteTokenProperties(collection, nestedToken, [key]), 796 ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;797 }798 799 i++;800 }801802 const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toJSON() as any[];803 expect(properties).to.be.empty;804 const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toJSON().properties as any[];805 expect(tokensData).to.be.empty;806 expect((await api.query.nonfungible.tokenProperties(collection, nestedToken)).toJSON().consumedSpace).to.be.equal(0);807 });808 });809});810811describe('Negative Integration Test: Token Properties', () => {812 let collection: number;813 let token: number;814 let originalSpace: number;815 let constitution: {permission: any, signers: IKeyringPair[], sinner: IKeyringPair}[];816817 before(async () => {818 await usingApi(async (api, privateKeyWrapper) => {819 alice = privateKeyWrapper('//Alice');820 bob = privateKeyWrapper('//Bob');821 charlie = privateKeyWrapper('//Charlie');822 const dave = privateKeyWrapper('//Dave');823824 constitution = [825 {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},826 {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},827 {permission: {mutable: true, tokenOwner: true}, signers: [charlie], sinner: alice},828 {permission: {mutable: false, tokenOwner: true}, signers: [charlie], sinner: alice},829 {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},830 {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},831 ];832 });833 });834835 beforeEach(async () => {836 collection = await createCollectionExpectSuccess();837 token = await createItemExpectSuccess(alice, collection, 'NFT');838 await addCollectionAdminExpectSuccess(alice, collection, bob.address);839 await transferExpectSuccess(collection, token, alice, charlie);840 841 await usingApi(async api => {842 let i = 0;843 for (const passage of constitution) {844 const signer = passage.signers[0];845 846 await expect(executeTransaction(847 api, 848 alice, 849 api.tx.unique.setTokenPropertyPermissions(collection, [{key: `${i}`, permission: passage.permission}]), 850 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;851852 await expect(executeTransaction(853 api, 854 signer, 855 api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin increase'}]), 856 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;857858 i++;859 }860861 originalSpace = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace as number;862 });863 });864865 it('Forbids changing/deleting properties of a token if the user is outside of permissions', async () => {866 await usingApi(async api => {867 let i = -1;868 for (const forbiddance of constitution) {869 i++;870 if (!forbiddance.permission.mutable) continue;871872 await expect(executeTransaction(873 api, 874 forbiddance.sinner, 875 api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 876 ), `on failing to change property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);877878 await expect(executeTransaction(879 api, 880 forbiddance.sinner, 881 api.tx.unique.deleteTokenProperties(collection, token, [`${i}`]), 882 ), `on failing to delete property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);883 }884885 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();886 expect(properties.consumedSpace).to.be.equal(originalSpace);887 });888 });889890 it('Forbids changing/deleting properties of a token if the property is permanent (immutable)', async () => {891 await usingApi(async api => {892 let i = -1;893 for (const permission of constitution) {894 i++;895 if (permission.permission.mutable) continue;896897 await expect(executeTransaction(898 api, 899 permission.signers[0], 900 api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 901 ), `on failing to change property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);902903 await expect(executeTransaction(904 api, 905 permission.signers[0], 906 api.tx.unique.deleteTokenProperties(collection, token, [i.toString()]), 907 ), `on failing to delete property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);908 }909910 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();911 expect(properties.consumedSpace).to.be.equal(originalSpace);912 });913 });914915 it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission', async () => {916 await usingApi(async api => {917 await expect(executeTransaction(918 api, 919 alice, 920 api.tx.unique.setTokenProperties(collection, token, [{key: 'non-existent', value: 'I exist!'}]), 921 ), 'on failing to add a previously non-existent property').to.be.rejectedWith(/common\.NoPermission/);922 923 await expect(executeTransaction(924 api, 925 alice, 926 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'now-existent', permission: {}}]), 927 ), 'on setting a new non-permitted property').to.not.be.rejected;928929 await expect(executeTransaction(930 api, 931 alice, 932 api.tx.unique.setTokenProperties(collection, token, [{key: 'now-existent', value: 'I exist!'}]), 933 ), 'on failing to add a property forbidden by the \'None\' permission').to.be.rejectedWith(/common\.NoPermission/);934935 expect((await api.rpc.unique.tokenProperties(collection, token, ['non-existent', 'now-existent'])).toJSON()).to.be.empty;936 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();937 expect(properties.consumedSpace).to.be.equal(originalSpace);938 });939 });940941 it('Forbids adding too many properties to a token', async () => {942 await usingApi(async api => {943 await expect(executeTransaction(944 api, 945 alice, 946 api.tx.unique.setTokenPropertyPermissions(collection, [947 {key: 'a_holy_book', permission: {collectionAdmin: true, tokenOwner: true}}, 948 {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},949 ]), 950 ), 'on setting a new non-permitted property').to.not.be.rejected;951952 953 {954 console.error = () => {};955 await expect(executeTransaction(956 api, 957 alice, 958 api.tx.unique.setCollectionProperties(collection, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]), 959 )).to.be.rejected;960 }961962 await expect(executeTransaction(963 api, 964 alice, 965 api.tx.unique.setTokenProperties(collection, token, [966 {key: 'a_holy_book', value: 'word '.repeat(3277)}, 967 {key: 'young_years', value: 'neverending'.repeat(1490)},968 ]), 969 )).to.be.rejectedWith(/common\.NoSpaceForProperty/);970971 expect((await api.rpc.unique.tokenProperties(collection, token, ['a_holy_book', 'young_years'])).toJSON()).to.be.empty;972 const propertiesMap = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();973 expect(propertiesMap.consumedSpace).to.be.equal(originalSpace);974 });975 });976});