1import {expect} from 'chai';2import usingApi, {executeTransaction} from '../substrate/substrate-api';3import {4 addCollectionAdminExpectSuccess,5 CollectionMode,6 createCollectionExpectSuccess,7 setCollectionPermissionsExpectSuccess,8 createItemExpectSuccess,9 getCreateCollectionResult,10 transferExpectSuccess,11} from '../util/helpers';12import {IKeyringPair} from '@polkadot/types/types';13import {tokenIdToAddress} from '../eth/util/helpers';1415let alice: IKeyringPair;16let bob: IKeyringPair;17let charlie: IKeyringPair;1819describe('Composite Properties Test', () => {20 before(async () => {21 await usingApi(async (api, privateKeyWrapper) => {22 alice = privateKeyWrapper('//Alice');23 bob = privateKeyWrapper('//Bob');24 });25 });2627 async function testMakeSureSuppliesRequired(mode: CollectionMode) {28 await usingApi(async api => {29 const collectionId = await createCollectionExpectSuccess({mode: mode});3031 const collectionOption = await api.rpc.unique.collectionById(collectionId);32 expect(collectionOption.isSome).to.be.true;33 let collection = collectionOption.unwrap();34 expect(collection.tokenPropertyPermissions.toHuman()).to.be.empty;35 expect(collection.properties.toHuman()).to.be.empty;3637 const propertyPermissions = [38 {key: 'mindgame', permission: {collectionAdmin: true, mutable: false, tokenOwner: true}},39 {key: 'skullduggery', permission: {collectionAdmin: false, mutable: true, tokenOwner: false}},40 ];41 await expect(executeTransaction(42 api, 43 alice, 44 api.tx.unique.setTokenPropertyPermissions(collectionId, propertyPermissions), 45 )).to.not.be.rejected;4647 const collectionProperties = [48 {key: 'black_hole', value: 'LIGO'},49 {key: 'electron', value: 'come bond'}, 50 ];51 await expect(executeTransaction(52 api, 53 alice, 54 api.tx.unique.setCollectionProperties(collectionId, collectionProperties), 55 )).to.not.be.rejected;5657 collection = (await api.rpc.unique.collectionById(collectionId)).unwrap();58 expect(collection.tokenPropertyPermissions.toHuman()).to.be.deep.equal(propertyPermissions);59 expect(collection.properties.toHuman()).to.be.deep.equal(collectionProperties);60 });61 }6263 it('Makes sure collectionById supplies required fields for NFT', async () => {64 await testMakeSureSuppliesRequired({type: 'NFT'});65 });6667 it('Makes sure collectionById supplies required fields for ReFungible', async () => {68 await testMakeSureSuppliesRequired({type: 'ReFungible'});69 });70});71727374describe('Integration Test: Collection Properties', () => {75 before(async () => {76 await usingApi(async (api, privateKeyWrapper) => {77 alice = privateKeyWrapper('//Alice');78 bob = privateKeyWrapper('//Bob');79 });80 });8182 it('Reads properties from a collection', async () => {83 await usingApi(async api => {84 const collection = await createCollectionExpectSuccess();85 const properties = (await api.query.common.collectionProperties(collection)).toJSON();86 expect(properties.map).to.be.empty;87 expect(properties.consumedSpace).to.equal(0);88 });89 });909192 async function testSetsPropertiesForCollection(mode: string) {93 await usingApi(async api => {94 const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));95 const {collectionId} = getCreateCollectionResult(events);9697 98 await expect(executeTransaction(99 api, 100 bob, 101 api.tx.unique.setCollectionProperties(collectionId, [{key: 'electron', value: 'come bond'}]), 102 )).to.not.be.rejected;103104 await addCollectionAdminExpectSuccess(bob, collectionId, alice.address);105106 107 await expect(executeTransaction(108 api, 109 alice, 110 api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 111 )).to.not.be.rejected;112113 const properties = (await api.rpc.unique.collectionProperties(collectionId, ['electron', 'black_hole'])).toHuman();114 expect(properties).to.be.deep.equal([115 {key: 'electron', value: 'come bond'},116 {key: 'black_hole', value: ''},117 ]);118 });119 }120 it('Sets properties for a NFT collection', async () => {121 await testSetsPropertiesForCollection('NFT');122 });123 it('Sets properties for a ReFungible collection', async () => {124 await testSetsPropertiesForCollection('ReFungible');125 });126127 async function testCheckValidNames(mode: string) {128 await usingApi(async api => {129 const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));130 const {collectionId} = getCreateCollectionResult(events);131 132 133 await expect(executeTransaction(134 api, 135 bob, 136 api.tx.unique.setCollectionProperties(collectionId, [{key: 'alpha'}]), 137 )).to.not.be.rejected;138 139 140 await expect(executeTransaction(141 api, 142 bob, 143 api.tx.unique.setCollectionProperties(collectionId, [{key: '123'}]), 144 )).to.not.be.rejected;145 146 147 await expect(executeTransaction(148 api, 149 bob, 150 api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 151 )).to.not.be.rejected;152 153 154 await expect(executeTransaction(155 api, 156 bob, 157 api.tx.unique.setCollectionProperties(collectionId, [{key: 'semi-automatic'}]), 158 )).to.not.be.rejected;159 160 161 await expect(executeTransaction(162 api, 163 bob, 164 api.tx.unique.setCollectionProperties(collectionId, [{key: 'build.rs'}]), 165 )).to.not.be.rejected;166 167 const propertyKeys = ['alpha', '123', 'black_hole', 'semi-automatic', 'build.rs'];168 const properties = (await api.rpc.unique.collectionProperties(collectionId, propertyKeys)).toHuman();169 expect(properties).to.be.deep.equal([170 {key: 'alpha', value: ''},171 {key: '123', value: ''},172 {key: 'black_hole', value: ''},173 {key: 'semi-automatic', value: ''},174 {key: 'build.rs', value: ''},175 ]);176 });177 }178 it('Check valid names for NFT collection properties keys', async () => {179 await testCheckValidNames('NFT');180 });181 it('Check valid names for ReFungible collection properties keys', async () => {182 await testCheckValidNames('ReFungible');183 });184185 async function testChangesProperties(mode: CollectionMode) {186 await usingApi(async api => {187 const collection = await createCollectionExpectSuccess({mode: mode});188 189 await expect(executeTransaction(190 api, 191 alice, 192 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole'}]), 193 )).to.not.be.rejected;194 195 196 await expect(executeTransaction(197 api, 198 alice, 199 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'bonded'}, {key: 'black_hole', value: 'LIGO'}]), 200 )).to.not.be.rejected;201 202 const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();203 expect(properties).to.be.deep.equal([204 {key: 'electron', value: 'bonded'},205 {key: 'black_hole', value: 'LIGO'},206 ]);207 });208 }209 it('Changes properties of a NFT collection', async () => {210 await testChangesProperties({type: 'NFT'});211 });212 it('Changes properties of a ReFungible collection', async () => {213 await testChangesProperties({type: 'ReFungible'});214 });215216 async function testDeleteProperties(mode: CollectionMode) {217 await usingApi(async api => {218 const collection = await createCollectionExpectSuccess({mode: mode});219 220 await expect(executeTransaction(221 api, 222 alice, 223 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 224 )).to.not.be.rejected;225 226 await expect(executeTransaction(227 api, 228 alice, 229 api.tx.unique.deleteCollectionProperties(collection, ['electron']), 230 )).to.not.be.rejected;231 232 const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();233 expect(properties).to.be.deep.equal([234 {key: 'black_hole', value: 'LIGO'},235 ]);236 }); 237 }238 it('Deletes properties of a NFT collection', async () => {239 await testDeleteProperties({type: 'NFT'});240 });241 it('Deletes properties of a ReFungible collection', async () => {242 await testDeleteProperties({type: 'ReFungible'});243 });244});245246describe('Negative Integration Test: Collection Properties', () => {247 before(async () => {248 await usingApi(async (api, privateKeyWrapper) => {249 alice = privateKeyWrapper('//Alice');250 bob = privateKeyWrapper('//Bob');251 });252 });253 254 async function testFailsSetPropertiesIfNotOwnerOrAdmin(mode: CollectionMode) {255 await usingApi(async api => {256 const collection = await createCollectionExpectSuccess({mode: mode});257 258 await expect(executeTransaction(259 api, 260 bob, 261 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 262 )).to.be.rejectedWith(/common\.NoPermission/);263 264 const properties = (await api.query.common.collectionProperties(collection)).toJSON();265 expect(properties.map).to.be.empty;266 expect(properties.consumedSpace).to.equal(0);267 }); 268 }269 it('Fails to set properties in a NFT collection if not its onwer/administrator', async () => {270 await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'NFT'});271 });272 it('Fails to set properties in a ReFungible collection if not its onwer/administrator', async () => {273 await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'ReFungible'});274 });275 276 async function testFailsSetPropertiesThatExeedLimits(mode: CollectionMode) {277 await usingApi(async api => {278 const collection = await createCollectionExpectSuccess({mode: mode});279 const spaceLimit = (await api.query.common.collectionProperties(collection)).toJSON().spaceLimit as number; 280 281 282 {283 console.error = () => {};284 await expect(executeTransaction(285 api, 286 alice, 287 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))}]), 288 )).to.be.rejected;289 }290 291 let properties = (await api.rpc.unique.collectionProperties(collection, ['electron'])).toJSON();292 expect(properties).to.be.empty;293 294 await expect(executeTransaction(295 api, 296 alice, 297 api.tx.unique.setCollectionProperties(collection, [298 {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, 299 {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, 300 ]), 301 )).to.be.rejectedWith(/common\.NoSpaceForProperty/);302 303 properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black hole'])).toJSON();304 expect(properties).to.be.empty;305 }); 306 }307 it('Fails to set properties that exceed the limits (NFT)', async () => {308 await testFailsSetPropertiesThatExeedLimits({type: 'NFT'});309 });310 it('Fails to set properties that exceed the limits (ReFungible)', async () => {311 await testFailsSetPropertiesThatExeedLimits({type: 'ReFungible'});312 });313 314 async function testFailsSetMorePropertiesThanAllowed(mode: CollectionMode) {315 await usingApi(async api => {316 const collection = await createCollectionExpectSuccess({mode: mode});317 318 const propertiesToBeSet = [];319 for (let i = 0; i < 65; i++) {320 propertiesToBeSet.push({321 key: 'electron_' + i,322 value: Math.random() > 0.5 ? 'high' : 'low',323 });324 }325 326 await expect(executeTransaction(327 api, 328 alice, 329 api.tx.unique.setCollectionProperties(collection, propertiesToBeSet), 330 )).to.be.rejectedWith(/common\.PropertyLimitReached/);331 332 const properties = (await api.query.common.collectionProperties(collection)).toJSON();333 expect(properties.map).to.be.empty;334 expect(properties.consumedSpace).to.equal(0);335 }); 336 }337 it('Fails to set more properties than it is allowed (NFT)', async () => {338 await testFailsSetMorePropertiesThanAllowed({type: 'NFT'});339 });340 it('Fails to set more properties than it is allowed (ReFungible)', async () => {341 await testFailsSetMorePropertiesThanAllowed({type: 'ReFungible'});342 });343 344 async function testFailsSetPropertiesWithInvalidNames(mode: CollectionMode) {345 await usingApi(async api => {346 const collection = await createCollectionExpectSuccess({mode: mode});347 348 const invalidProperties = [349 [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],350 [{key: 'Mr/Sandman', value: 'Bring me a gene'}],351 [{key: 'déjà vu', value: 'hmm...'}],352 ];353 354 for (let i = 0; i < invalidProperties.length; i++) {355 await expect(executeTransaction(356 api, 357 alice, 358 api.tx.unique.setCollectionProperties(collection, invalidProperties[i]), 359 ), `on rejecting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);360 }361 362 await expect(executeTransaction(363 api, 364 alice, 365 api.tx.unique.setCollectionProperties(collection, [{key: '', value: 'nothing must not exist'}]), 366 ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);367 368 await expect(executeTransaction(369 api, 370 alice, 371 api.tx.unique.setCollectionProperties(collection, [372 {key: 'CRISPR-Cas9', value: 'rewriting nature!'},373 ]), 374 ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;375 376 const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');377 378 const properties = (await api.rpc.unique.collectionProperties(collection, keys)).toHuman();379 expect(properties).to.be.deep.equal([380 {key: 'CRISPR-Cas9', value: 'rewriting nature!'},381 ]);382 383 for (let i = 0; i < invalidProperties.length; i++) {384 await expect(executeTransaction(385 api, 386 alice, 387 api.tx.unique.deleteCollectionProperties(collection, invalidProperties[i].map(propertySet => propertySet.key)), 388 ), `on trying to delete the non-existent badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);389 }390 });391 }392 it('Fails to set properties with invalid names (NFT)', async () => {393 await testFailsSetPropertiesWithInvalidNames({type: 'NFT'});394 });395 it('Fails to set properties with invalid names (ReFungible)', async () => {396 await testFailsSetPropertiesWithInvalidNames({type: 'ReFungible'});397 });398});399400401402describe('Integration Test: Access Rights to Token Properties', () => {403 before(async () => {404 await usingApi(async (api, privateKeyWrapper) => {405 alice = privateKeyWrapper('//Alice');406 bob = privateKeyWrapper('//Bob');407 });408 });409 410 it('Reads access rights to properties of a collection', async () => {411 await usingApi(async api => {412 const collection = await createCollectionExpectSuccess();413 const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();414 expect(propertyRights).to.be.empty;415 });416 });417 418 async function testSetsAccessRightsToProperties(mode: CollectionMode) {419 await usingApi(async api => {420 const collection = await createCollectionExpectSuccess({mode: mode});421 422 await expect(executeTransaction(423 api, 424 alice, 425 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true}}]), 426 )).to.not.be.rejected;427 428 await addCollectionAdminExpectSuccess(alice, collection, bob.address);429 430 await expect(executeTransaction(431 api, 432 alice, 433 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]), 434 )).to.not.be.rejected;435 436 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery', 'mindgame'])).toHuman();437 expect(propertyRights).to.be.deep.equal([438 {key: 'skullduggery', permission: {'mutable': true, 'collectionAdmin': false, 'tokenOwner': false}},439 {key: 'mindgame', permission: {'mutable': false, 'collectionAdmin': true, 'tokenOwner': false}},440 ]);441 }); 442 }443 it('Sets access rights to properties of a collection (NFT)', async () => {444 await testSetsAccessRightsToProperties({type: 'NFT'});445 });446 it('Sets access rights to properties of a collection (ReFungible)', async () => {447 await testSetsAccessRightsToProperties({type: 'ReFungible'});448 });449 450 async function testChangesAccessRightsToProperty(mode: CollectionMode) {451 await usingApi(async api => {452 const collection = await createCollectionExpectSuccess({mode: mode});453 454 await expect(executeTransaction(455 api, 456 alice, 457 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]), 458 )).to.not.be.rejected;459 460 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;465 466 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();467 expect(propertyRights).to.be.deep.equal([468 {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},469 ]);470 });471 }472 it('Changes access rights to properties of a NFT collection', async () => {473 await testChangesAccessRightsToProperty({type: 'NFT'});474 });475 it('Changes access rights to properties of a ReFungible collection', async () => {476 await testChangesAccessRightsToProperty({type: 'ReFungible'});477 });478});479480describe('Negative Integration Test: Access Rights to Token Properties', () => {481 before(async () => {482 await usingApi(async (api, privateKeyWrapper) => {483 alice = privateKeyWrapper('//Alice');484 bob = privateKeyWrapper('//Bob');485 });486 });487488 async function testPreventsFromSettingAccessRightsNotAdminOrOwner(mode: CollectionMode) {489 await usingApi(async api => {490 const collection = await createCollectionExpectSuccess({mode: mode});491 492 await expect(executeTransaction(493 api, 494 bob, 495 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]), 496 )).to.be.rejectedWith(/common\.NoPermission/);497 498 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toJSON();499 expect(propertyRights).to.be.empty;500 });501 }502 it('Prevents from setting access rights to properties of a NFT collection if not an onwer/admin', async () => {503 await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'NFT'});504 });505 it('Prevents from setting access rights to properties of a ReFungible collection if not an onwer/admin', async () => {506 await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'ReFungible'});507 });508509 async function testPreventFromAddingTooManyPossibleProperties(mode: CollectionMode) {510 await usingApi(async api => {511 const collection = await createCollectionExpectSuccess({mode: mode});512 513 const constitution = [];514 for (let i = 0; i < 65; i++) {515 constitution.push({516 key: 'property_' + i,517 permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},518 });519 }520 521 await expect(executeTransaction(522 api, 523 alice, 524 api.tx.unique.setTokenPropertyPermissions(collection, constitution), 525 )).to.be.rejectedWith(/common\.PropertyLimitReached/);526 527 const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();528 expect(propertyRights).to.be.empty;529 }); 530 }531 it('Prevents from adding too many possible properties (NFT)', async () => {532 await testPreventFromAddingTooManyPossibleProperties({type: 'NFT'});533 });534 it('Prevents from adding too many possible properties (ReFungible)', async () => {535 await testPreventFromAddingTooManyPossibleProperties({type: 'ReFungible'});536 });537538 async function testPreventAccessRightsModifiedIfConstant(mode: CollectionMode) {539 await usingApi(async api => {540 const collection = await createCollectionExpectSuccess({mode: mode});541 542 await expect(executeTransaction(543 api, 544 alice, 545 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 546 )).to.not.be.rejected;547 548 await expect(executeTransaction(549 api, 550 alice, 551 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {}}]), 552 )).to.be.rejectedWith(/common\.NoPermission/);553 554 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();555 expect(propertyRights).to.deep.equal([556 {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},557 ]);558 }); 559 }560 it('Prevents access rights to be modified if constant (NFT)', async () => {561 await testPreventAccessRightsModifiedIfConstant({type: 'NFT'});562 });563 it('Prevents access rights to be modified if constant (ReFungible)', async () => {564 await testPreventAccessRightsModifiedIfConstant({type: 'ReFungible'});565 });566567 async function testPreventsAddingPropertiesWithInvalidNames(mode: CollectionMode) {568 await usingApi(async api => {569 const collection = await createCollectionExpectSuccess({mode: mode});570 571 const invalidProperties = [572 [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],573 [{key: 'G#4', permission: {tokenOwner: true}}],574 [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],575 ];576 577 for (let i = 0; i < invalidProperties.length; i++) {578 await expect(executeTransaction(579 api, 580 alice, 581 api.tx.unique.setTokenPropertyPermissions(collection, invalidProperties[i]), 582 ), `on setting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);583 }584 585 await expect(executeTransaction(586 api, 587 alice, 588 api.tx.unique.setTokenPropertyPermissions(collection, [{key: '', permission: {}}]), 589 ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);590 591 const correctKey = '--0x03116e387820CA05'; 592 await expect(executeTransaction(593 api, 594 alice, 595 api.tx.unique.setTokenPropertyPermissions(collection, [596 {key: correctKey, permission: {collectionAdmin: true}},597 ]), 598 ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;599 600 const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');601 602 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, keys)).toHuman();603 expect(propertyRights).to.be.deep.equal([604 {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},605 ]);606 });607 }608 it('Prevents adding properties with invalid names (NFT)', async () => {609 await testPreventsAddingPropertiesWithInvalidNames({type: 'NFT'});610 });611 it('Prevents adding properties with invalid names (ReFungible)', async () => {612 await testPreventsAddingPropertiesWithInvalidNames({type: 'ReFungible'});613 });614});615616617618describe('Integration Test: Token Properties', () => {619 let collection: number;620 let token: number;621 let nestedToken: number;622 let permissions: {permission: any, signers: IKeyringPair[]}[];623624 before(async () => {625 await usingApi(async (api, privateKeyWrapper) => {626 alice = privateKeyWrapper('//Alice');627 bob = privateKeyWrapper('//Bob');628 charlie = privateKeyWrapper('//Charlie');629630 permissions = [631 {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},632 {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]},633 {permission: {mutable: true, tokenOwner: true}, signers: [charlie]},634 {permission: {mutable: false, tokenOwner: true}, signers: [charlie]},635 {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},636 {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},637 ];638 });639 });640641 beforeEach(async () => {642 await usingApi(async () => {643 collection = await createCollectionExpectSuccess();644 await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});645646 token = await createItemExpectSuccess(alice, collection, 'NFT');647 nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});648649 await addCollectionAdminExpectSuccess(alice, collection, bob.address);650 await transferExpectSuccess(collection, token, alice, charlie);651 });652 });653 654 it('Reads yet empty properties of a token', async () => {655 await usingApi(async api => {656 const collection = await createCollectionExpectSuccess();657 const token = await createItemExpectSuccess(alice, collection, 'NFT');658 659 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();660 expect(properties.map).to.be.empty;661 expect(properties.consumedSpace).to.be.equal(0);662663 const tokenData = (await api.rpc.unique.tokenData(collection, token, ['anything'])).toJSON().properties;664 expect(tokenData).to.be.empty;665 });666 });667668 it('Assigns properties to a token according to permissions', async () => {669 await usingApi(async api => {670 const propertyKeys: string[] = [];671 let i = 0;672 for (const permission of permissions) {673 for (const signer of permission.signers) {674 const key = i + '_' + signer.address;675 propertyKeys.push(key);676677 await expect(executeTransaction(678 api, 679 alice, 680 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 681 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;682683 await expect(executeTransaction(684 api, 685 signer, 686 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 687 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;688 }689690 i++;691 }692693 const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];694 const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];695 for (let i = 0; i < properties.length; i++) {696 expect(properties[i].value).to.be.equal('Serotonin increase');697 expect(tokensData[i].value).to.be.equal('Serotonin increase');698 }699 });700 });701702 it('Changes properties of a token according to permissions', async () => {703 await usingApi(async api => {704 const propertyKeys: string[] = [];705 let i = 0;706 for (const permission of permissions) {707 if (!permission.permission.mutable) continue;708 709 for (const signer of permission.signers) {710 const key = i + '_' + signer.address;711 propertyKeys.push(key);712713 await expect(executeTransaction(714 api, 715 alice, 716 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 717 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;718719 await expect(executeTransaction(720 api, 721 signer, 722 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 723 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;724725 await expect(executeTransaction(726 api, 727 signer, 728 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin stable'}]), 729 ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;730 }731732 i++;733 }734735 const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];736 const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];737 for (let i = 0; i < properties.length; i++) {738 expect(properties[i].value).to.be.equal('Serotonin stable');739 expect(tokensData[i].value).to.be.equal('Serotonin stable');740 }741 });742 });743744 it('Deletes properties of a token according to permissions', async () => {745 await usingApi(async api => {746 const propertyKeys: string[] = [];747 let i = 0;748749 for (const permission of permissions) {750 if (!permission.permission.mutable) continue;751 752 for (const signer of permission.signers) {753 const key = i + '_' + signer.address;754 propertyKeys.push(key);755756 await expect(executeTransaction(757 api, 758 alice, 759 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 760 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;761762 await expect(executeTransaction(763 api, 764 signer, 765 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 766 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;767768 await expect(executeTransaction(769 api, 770 signer, 771 api.tx.unique.deleteTokenProperties(collection, token, [key]), 772 ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;773 }774 775 i++;776 }777778 const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toJSON() as any[];779 expect(properties).to.be.empty;780 const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toJSON().properties as any[];781 expect(tokensData).to.be.empty;782 expect((await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace).to.be.equal(0);783 });784 });785786 it('Assigns properties to a nested token according to permissions', async () => {787 await usingApi(async api => {788 const propertyKeys: string[] = [];789 let i = 0;790 for (const permission of permissions) {791 for (const signer of permission.signers) {792 const key = i + '_' + signer.address;793 propertyKeys.push(key);794795 await expect(executeTransaction(796 api, 797 alice, 798 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 799 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;800801 await expect(executeTransaction(802 api, 803 signer, 804 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 805 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;806 }807808 i++;809 }810811 const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];812 const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];813 for (let i = 0; i < properties.length; i++) {814 expect(properties[i].value).to.be.equal('Serotonin increase');815 expect(tokensData[i].value).to.be.equal('Serotonin increase');816 }817 });818 });819820 it('Changes properties of a nested token according to permissions', async () => {821 await usingApi(async api => {822 const propertyKeys: string[] = [];823 let i = 0;824 for (const permission of permissions) {825 if (!permission.permission.mutable) continue;826 827 for (const signer of permission.signers) {828 const key = i + '_' + signer.address;829 propertyKeys.push(key);830831 await expect(executeTransaction(832 api, 833 alice, 834 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 835 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;836837 await expect(executeTransaction(838 api, 839 signer, 840 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 841 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;842843 await expect(executeTransaction(844 api, 845 signer, 846 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin stable'}]), 847 ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;848 }849850 i++;851 }852853 const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];854 const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];855 for (let i = 0; i < properties.length; i++) {856 expect(properties[i].value).to.be.equal('Serotonin stable');857 expect(tokensData[i].value).to.be.equal('Serotonin stable');858 }859 });860 });861862 it('Deletes properties of a nested token according to permissions', async () => {863 await usingApi(async api => {864 const propertyKeys: string[] = [];865 let i = 0;866867 for (const permission of permissions) {868 if (!permission.permission.mutable) continue;869 870 for (const signer of permission.signers) {871 const key = i + '_' + signer.address;872 propertyKeys.push(key);873874 await expect(executeTransaction(875 api, 876 alice, 877 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 878 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;879880 await expect(executeTransaction(881 api, 882 signer, 883 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 884 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;885886 await expect(executeTransaction(887 api, 888 signer, 889 api.tx.unique.deleteTokenProperties(collection, nestedToken, [key]), 890 ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;891 }892 893 i++;894 }895896 const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toJSON() as any[];897 expect(properties).to.be.empty;898 const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toJSON().properties as any[];899 expect(tokensData).to.be.empty;900 expect((await api.query.nonfungible.tokenProperties(collection, nestedToken)).toJSON().consumedSpace).to.be.equal(0);901 });902 });903});904905describe('Negative Integration Test: Token Properties', () => {906 let collection: number;907 let token: number;908 let originalSpace: number;909 let constitution: {permission: any, signers: IKeyringPair[], sinner: IKeyringPair}[];910911 before(async () => {912 await usingApi(async (api, privateKeyWrapper) => {913 alice = privateKeyWrapper('//Alice');914 bob = privateKeyWrapper('//Bob');915 charlie = privateKeyWrapper('//Charlie');916 const dave = privateKeyWrapper('//Dave');917918 constitution = [919 {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},920 {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},921 {permission: {mutable: true, tokenOwner: true}, signers: [charlie], sinner: alice},922 {permission: {mutable: false, tokenOwner: true}, signers: [charlie], sinner: alice},923 {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},924 {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},925 ];926 });927 });928929 beforeEach(async () => {930 collection = await createCollectionExpectSuccess();931 token = await createItemExpectSuccess(alice, collection, 'NFT');932 await addCollectionAdminExpectSuccess(alice, collection, bob.address);933 await transferExpectSuccess(collection, token, alice, charlie);934 935 await usingApi(async api => {936 let i = 0;937 for (const passage of constitution) {938 const signer = passage.signers[0];939 940 await expect(executeTransaction(941 api, 942 alice, 943 api.tx.unique.setTokenPropertyPermissions(collection, [{key: `${i}`, permission: passage.permission}]), 944 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;945946 await expect(executeTransaction(947 api, 948 signer, 949 api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin increase'}]), 950 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;951952 i++;953 }954955 originalSpace = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace as number;956 });957 });958959 it('Forbids changing/deleting properties of a token if the user is outside of permissions', async () => {960 await usingApi(async api => {961 let i = -1;962 for (const forbiddance of constitution) {963 i++;964 if (!forbiddance.permission.mutable) continue;965966 await expect(executeTransaction(967 api, 968 forbiddance.sinner, 969 api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 970 ), `on failing to change property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);971972 await expect(executeTransaction(973 api, 974 forbiddance.sinner, 975 api.tx.unique.deleteTokenProperties(collection, token, [`${i}`]), 976 ), `on failing to delete property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);977 }978979 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();980 expect(properties.consumedSpace).to.be.equal(originalSpace);981 });982 });983984 it('Forbids changing/deleting properties of a token if the property is permanent (immutable)', async () => {985 await usingApi(async api => {986 let i = -1;987 for (const permission of constitution) {988 i++;989 if (permission.permission.mutable) continue;990991 await expect(executeTransaction(992 api, 993 permission.signers[0], 994 api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 995 ), `on failing to change property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);996997 await expect(executeTransaction(998 api, 999 permission.signers[0], 1000 api.tx.unique.deleteTokenProperties(collection, token, [i.toString()]), 1001 ), `on failing to delete property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);1002 }10031004 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();1005 expect(properties.consumedSpace).to.be.equal(originalSpace);1006 });1007 });10081009 it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission', async () => {1010 await usingApi(async api => {1011 await expect(executeTransaction(1012 api, 1013 alice, 1014 api.tx.unique.setTokenProperties(collection, token, [{key: 'non-existent', value: 'I exist!'}]), 1015 ), 'on failing to add a previously non-existent property').to.be.rejectedWith(/common\.NoPermission/);1016 1017 await expect(executeTransaction(1018 api, 1019 alice, 1020 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'now-existent', permission: {}}]), 1021 ), 'on setting a new non-permitted property').to.not.be.rejected;10221023 await expect(executeTransaction(1024 api, 1025 alice, 1026 api.tx.unique.setTokenProperties(collection, token, [{key: 'now-existent', value: 'I exist!'}]), 1027 ), 'on failing to add a property forbidden by the \'None\' permission').to.be.rejectedWith(/common\.NoPermission/);10281029 expect((await api.rpc.unique.tokenProperties(collection, token, ['non-existent', 'now-existent'])).toJSON()).to.be.empty;1030 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();1031 expect(properties.consumedSpace).to.be.equal(originalSpace);1032 });1033 });10341035 it('Forbids adding too many properties to a token', async () => {1036 await usingApi(async api => {1037 await expect(executeTransaction(1038 api, 1039 alice, 1040 api.tx.unique.setTokenPropertyPermissions(collection, [1041 {key: 'a_holy_book', permission: {collectionAdmin: true, tokenOwner: true}}, 1042 {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},1043 ]), 1044 ), 'on setting a new non-permitted property').to.not.be.rejected;10451046 1047 {1048 console.error = () => {};1049 await expect(executeTransaction(1050 api, 1051 alice, 1052 api.tx.unique.setCollectionProperties(collection, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]), 1053 )).to.be.rejected;1054 }10551056 await expect(executeTransaction(1057 api, 1058 alice, 1059 api.tx.unique.setTokenProperties(collection, token, [1060 {key: 'a_holy_book', value: 'word '.repeat(3277)}, 1061 {key: 'young_years', value: 'neverending'.repeat(1490)},1062 ]), 1063 )).to.be.rejectedWith(/common\.NoSpaceForProperty/);10641065 expect((await api.rpc.unique.tokenProperties(collection, token, ['a_holy_book', 'young_years'])).toJSON()).to.be.empty;1066 const propertiesMap = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();1067 expect(propertiesMap.consumedSpace).to.be.equal(originalSpace);1068 });1069 });1070});