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 requirePallets,12 Pallets,13} from '../util/helpers';14import {IKeyringPair} from '@polkadot/types/types';15import {tokenIdToAddress} from '../eth/util/helpers';1617let alice: IKeyringPair;18let bob: IKeyringPair;19let charlie: IKeyringPair;2021describe('Composite Properties Test', () => {22 before(async () => {23 await usingApi(async (api, privateKeyWrapper) => {24 alice = privateKeyWrapper('//Alice');25 bob = privateKeyWrapper('//Bob');26 });27 });2829 async function testMakeSureSuppliesRequired(mode: CollectionMode) {30 await usingApi(async api => {31 const collectionId = await createCollectionExpectSuccess({mode: mode});3233 const collectionOption = await api.rpc.unique.collectionById(collectionId);34 expect(collectionOption.isSome).to.be.true;35 let collection = collectionOption.unwrap();36 expect(collection.tokenPropertyPermissions.toHuman()).to.be.empty;37 expect(collection.properties.toHuman()).to.be.empty;3839 const propertyPermissions = [40 {key: 'mindgame', permission: {collectionAdmin: true, mutable: false, tokenOwner: true}},41 {key: 'skullduggery', permission: {collectionAdmin: false, mutable: true, tokenOwner: false}},42 ];43 await expect(executeTransaction(44 api, 45 alice, 46 api.tx.unique.setTokenPropertyPermissions(collectionId, propertyPermissions), 47 )).to.not.be.rejected;4849 const collectionProperties = [50 {key: 'black_hole', value: 'LIGO'},51 {key: 'electron', value: 'come bond'}, 52 ];53 await expect(executeTransaction(54 api, 55 alice, 56 api.tx.unique.setCollectionProperties(collectionId, collectionProperties), 57 )).to.not.be.rejected;5859 collection = (await api.rpc.unique.collectionById(collectionId)).unwrap();60 expect(collection.tokenPropertyPermissions.toHuman()).to.be.deep.equal(propertyPermissions);61 expect(collection.properties.toHuman()).to.be.deep.equal(collectionProperties);62 });63 }6465 it('Makes sure collectionById supplies required fields for NFT', async () => {66 await testMakeSureSuppliesRequired({type: 'NFT'});67 });6869 it('Makes sure collectionById supplies required fields for ReFungible', async function() {70 await requirePallets(this, [Pallets.ReFungible]);7172 await testMakeSureSuppliesRequired({type: 'ReFungible'});73 });74});75767778describe('Integration Test: Collection Properties', () => {79 before(async () => {80 await usingApi(async (api, privateKeyWrapper) => {81 alice = privateKeyWrapper('//Alice');82 bob = privateKeyWrapper('//Bob');83 });84 });8586 it('Reads properties from a collection', async () => {87 await usingApi(async api => {88 const collection = await createCollectionExpectSuccess();89 const properties = (await api.query.common.collectionProperties(collection)).toJSON();90 expect(properties.map).to.be.empty;91 expect(properties.consumedSpace).to.equal(0);92 });93 });949596 async function testSetsPropertiesForCollection(mode: string) {97 await usingApi(async api => {98 const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));99 const {collectionId} = getCreateCollectionResult(events);100101 102 await expect(executeTransaction(103 api, 104 bob, 105 api.tx.unique.setCollectionProperties(collectionId, [{key: 'electron', value: 'come bond'}]), 106 )).to.not.be.rejected;107108 await addCollectionAdminExpectSuccess(bob, collectionId, alice.address);109110 111 await expect(executeTransaction(112 api, 113 alice, 114 api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 115 )).to.not.be.rejected;116117 const properties = (await api.rpc.unique.collectionProperties(collectionId, ['electron', 'black_hole'])).toHuman();118 expect(properties).to.be.deep.equal([119 {key: 'electron', value: 'come bond'},120 {key: 'black_hole', value: ''},121 ]);122 });123 }124 it('Sets properties for a NFT collection', async () => {125 await testSetsPropertiesForCollection('NFT');126 });127 it('Sets properties for a ReFungible collection', async function() {128 await requirePallets(this, [Pallets.ReFungible]);129130 await testSetsPropertiesForCollection('ReFungible');131 });132133 async function testCheckValidNames(mode: string) {134 await usingApi(async api => {135 const events = await executeTransaction(api, bob, api.tx.unique.createCollectionEx({mode: mode}));136 const {collectionId} = getCreateCollectionResult(events);137 138 139 await expect(executeTransaction(140 api, 141 bob, 142 api.tx.unique.setCollectionProperties(collectionId, [{key: 'alpha'}]), 143 )).to.not.be.rejected;144 145 146 await expect(executeTransaction(147 api, 148 bob, 149 api.tx.unique.setCollectionProperties(collectionId, [{key: '123'}]), 150 )).to.not.be.rejected;151 152 153 await expect(executeTransaction(154 api, 155 bob, 156 api.tx.unique.setCollectionProperties(collectionId, [{key: 'black_hole'}]), 157 )).to.not.be.rejected;158 159 160 await expect(executeTransaction(161 api, 162 bob, 163 api.tx.unique.setCollectionProperties(collectionId, [{key: 'semi-automatic'}]), 164 )).to.not.be.rejected;165 166 167 await expect(executeTransaction(168 api, 169 bob, 170 api.tx.unique.setCollectionProperties(collectionId, [{key: 'build.rs'}]), 171 )).to.not.be.rejected;172 173 const propertyKeys = ['alpha', '123', 'black_hole', 'semi-automatic', 'build.rs'];174 const properties = (await api.rpc.unique.collectionProperties(collectionId, propertyKeys)).toHuman();175 expect(properties).to.be.deep.equal([176 {key: 'alpha', value: ''},177 {key: '123', value: ''},178 {key: 'black_hole', value: ''},179 {key: 'semi-automatic', value: ''},180 {key: 'build.rs', value: ''},181 ]);182 });183 }184 it('Check valid names for NFT collection properties keys', async () => {185 await testCheckValidNames('NFT');186 });187 it('Check valid names for ReFungible collection properties keys', async function() {188 await requirePallets(this, [Pallets.ReFungible]);189190 await testCheckValidNames('ReFungible');191 });192193 async function testChangesProperties(mode: CollectionMode) {194 await usingApi(async api => {195 const collection = await createCollectionExpectSuccess({mode: mode});196 197 await expect(executeTransaction(198 api, 199 alice, 200 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole'}]), 201 )).to.not.be.rejected;202 203 204 await expect(executeTransaction(205 api, 206 alice, 207 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'bonded'}, {key: 'black_hole', value: 'LIGO'}]), 208 )).to.not.be.rejected;209 210 const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();211 expect(properties).to.be.deep.equal([212 {key: 'electron', value: 'bonded'},213 {key: 'black_hole', value: 'LIGO'},214 ]);215 });216 }217 it('Changes properties of a NFT collection', async () => {218 await testChangesProperties({type: 'NFT'});219 });220 it('Changes properties of a ReFungible collection', async function() {221 await requirePallets(this, [Pallets.ReFungible]);222223 await testChangesProperties({type: 'ReFungible'});224 });225226 async function testDeleteProperties(mode: CollectionMode) {227 await usingApi(async api => {228 const collection = await createCollectionExpectSuccess({mode: mode});229 230 await expect(executeTransaction(231 api, 232 alice, 233 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 234 )).to.not.be.rejected;235 236 await expect(executeTransaction(237 api, 238 alice, 239 api.tx.unique.deleteCollectionProperties(collection, ['electron']), 240 )).to.not.be.rejected;241 242 const properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black_hole'])).toHuman();243 expect(properties).to.be.deep.equal([244 {key: 'black_hole', value: 'LIGO'},245 ]);246 }); 247 }248 it('Deletes properties of a NFT collection', async () => {249 await testDeleteProperties({type: 'NFT'});250 });251 it('Deletes properties of a ReFungible collection', async function() {252 await requirePallets(this, [Pallets.ReFungible]);253254 await testDeleteProperties({type: 'ReFungible'});255 });256});257258describe('Negative Integration Test: Collection Properties', () => {259 before(async () => {260 await usingApi(async (api, privateKeyWrapper) => {261 alice = privateKeyWrapper('//Alice');262 bob = privateKeyWrapper('//Bob');263 });264 });265 266 async function testFailsSetPropertiesIfNotOwnerOrAdmin(mode: CollectionMode) {267 await usingApi(async api => {268 const collection = await createCollectionExpectSuccess({mode: mode});269 270 await expect(executeTransaction(271 api, 272 bob, 273 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'come bond'}, {key: 'black_hole', value: 'LIGO'}]), 274 )).to.be.rejectedWith(/common\.NoPermission/);275 276 const properties = (await api.query.common.collectionProperties(collection)).toJSON();277 expect(properties.map).to.be.empty;278 expect(properties.consumedSpace).to.equal(0);279 }); 280 }281 it('Fails to set properties in a NFT collection if not its onwer/administrator', async () => {282 await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'NFT'});283 });284 it('Fails to set properties in a ReFungible collection if not its onwer/administrator', async function() {285 await requirePallets(this, [Pallets.ReFungible]);286287 await testFailsSetPropertiesIfNotOwnerOrAdmin({type: 'ReFungible'});288 });289 290 async function testFailsSetPropertiesThatExeedLimits(mode: CollectionMode) {291 await usingApi(async api => {292 const collection = await createCollectionExpectSuccess({mode: mode});293 const spaceLimit = (await api.query.common.collectionProperties(collection)).toJSON().spaceLimit as number; 294 295 296 {297 console.error = () => {};298 await expect(executeTransaction(299 api, 300 alice, 301 api.tx.unique.setCollectionProperties(collection, [{key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 9))}]), 302 )).to.be.rejected;303 }304 305 let properties = (await api.rpc.unique.collectionProperties(collection, ['electron'])).toJSON();306 expect(properties).to.be.empty;307 308 await expect(executeTransaction(309 api, 310 alice, 311 api.tx.unique.setCollectionProperties(collection, [312 {key: 'electron', value: 'low high '.repeat(Math.ceil(spaceLimit! / 18))}, 313 {key: 'black_hole', value: '0'.repeat(Math.ceil(spaceLimit! / 2))}, 314 ]), 315 )).to.be.rejectedWith(/common\.NoSpaceForProperty/);316 317 properties = (await api.rpc.unique.collectionProperties(collection, ['electron', 'black hole'])).toJSON();318 expect(properties).to.be.empty;319 }); 320 }321 it('Fails to set properties that exceed the limits (NFT)', async () => {322 await testFailsSetPropertiesThatExeedLimits({type: 'NFT'});323 });324 it('Fails to set properties that exceed the limits (ReFungible)', async function() {325 await requirePallets(this, [Pallets.ReFungible]);326327 await testFailsSetPropertiesThatExeedLimits({type: 'ReFungible'});328 });329 330 async function testFailsSetMorePropertiesThanAllowed(mode: CollectionMode) {331 await usingApi(async api => {332 const collection = await createCollectionExpectSuccess({mode: mode});333 334 const propertiesToBeSet = [];335 for (let i = 0; i < 65; i++) {336 propertiesToBeSet.push({337 key: 'electron_' + i,338 value: Math.random() > 0.5 ? 'high' : 'low',339 });340 }341 342 await expect(executeTransaction(343 api, 344 alice, 345 api.tx.unique.setCollectionProperties(collection, propertiesToBeSet), 346 )).to.be.rejectedWith(/common\.PropertyLimitReached/);347 348 const properties = (await api.query.common.collectionProperties(collection)).toJSON();349 expect(properties.map).to.be.empty;350 expect(properties.consumedSpace).to.equal(0);351 }); 352 }353 it('Fails to set more properties than it is allowed (NFT)', async () => {354 await testFailsSetMorePropertiesThanAllowed({type: 'NFT'});355 });356 it('Fails to set more properties than it is allowed (ReFungible)', async function() {357 await requirePallets(this, [Pallets.ReFungible]);358359 await testFailsSetMorePropertiesThanAllowed({type: 'ReFungible'});360 });361 362 async function testFailsSetPropertiesWithInvalidNames(mode: CollectionMode) {363 await usingApi(async api => {364 const collection = await createCollectionExpectSuccess({mode: mode});365 366 const invalidProperties = [367 [{key: 'electron', value: 'negative'}, {key: 'string theory', value: 'understandable'}],368 [{key: 'Mr/Sandman', value: 'Bring me a gene'}],369 [{key: 'déjà vu', value: 'hmm...'}],370 ];371 372 for (let i = 0; i < invalidProperties.length; i++) {373 await expect(executeTransaction(374 api, 375 alice, 376 api.tx.unique.setCollectionProperties(collection, invalidProperties[i]), 377 ), `on rejecting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);378 }379 380 await expect(executeTransaction(381 api, 382 alice, 383 api.tx.unique.setCollectionProperties(collection, [{key: '', value: 'nothing must not exist'}]), 384 ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);385 386 await expect(executeTransaction(387 api, 388 alice, 389 api.tx.unique.setCollectionProperties(collection, [390 {key: 'CRISPR-Cas9', value: 'rewriting nature!'},391 ]), 392 ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;393 394 const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat('CRISPR-Cas9').concat('');395 396 const properties = (await api.rpc.unique.collectionProperties(collection, keys)).toHuman();397 expect(properties).to.be.deep.equal([398 {key: 'CRISPR-Cas9', value: 'rewriting nature!'},399 ]);400 401 for (let i = 0; i < invalidProperties.length; i++) {402 await expect(executeTransaction(403 api, 404 alice, 405 api.tx.unique.deleteCollectionProperties(collection, invalidProperties[i].map(propertySet => propertySet.key)), 406 ), `on trying to delete the non-existent badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);407 }408 });409 }410 it('Fails to set properties with invalid names (NFT)', async () => {411 await testFailsSetPropertiesWithInvalidNames({type: 'NFT'});412 });413 it('Fails to set properties with invalid names (ReFungible)', async function() {414 await requirePallets(this, [Pallets.ReFungible]);415416 await testFailsSetPropertiesWithInvalidNames({type: 'ReFungible'});417 });418});419420421422describe('Integration Test: Access Rights to Token Properties', () => {423 before(async () => {424 await usingApi(async (api, privateKeyWrapper) => {425 alice = privateKeyWrapper('//Alice');426 bob = privateKeyWrapper('//Bob');427 });428 });429 430 it('Reads access rights to properties of a collection', async () => {431 await usingApi(async api => {432 const collection = await createCollectionExpectSuccess();433 const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();434 expect(propertyRights).to.be.empty;435 });436 });437 438 async function testSetsAccessRightsToProperties(mode: CollectionMode) {439 await usingApi(async api => {440 const collection = await createCollectionExpectSuccess({mode: mode});441 442 await expect(executeTransaction(443 api, 444 alice, 445 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true}}]), 446 )).to.not.be.rejected;447 448 await addCollectionAdminExpectSuccess(alice, collection, bob.address);449 450 await expect(executeTransaction(451 api, 452 alice, 453 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'mindgame', permission: {collectionAdmin: true, tokenOwner: false}}]), 454 )).to.not.be.rejected;455 456 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery', 'mindgame'])).toHuman();457 expect(propertyRights).to.be.deep.equal([458 {key: 'skullduggery', permission: {'mutable': true, 'collectionAdmin': false, 'tokenOwner': false}},459 {key: 'mindgame', permission: {'mutable': false, 'collectionAdmin': true, 'tokenOwner': false}},460 ]);461 }); 462 }463 it('Sets access rights to properties of a collection (NFT)', async () => {464 await testSetsAccessRightsToProperties({type: 'NFT'});465 });466 it('Sets access rights to properties of a collection (ReFungible)', async function() {467 await requirePallets(this, [Pallets.ReFungible]);468469 await testSetsAccessRightsToProperties({type: 'ReFungible'});470 });471 472 async function testChangesAccessRightsToProperty(mode: CollectionMode) {473 await usingApi(async api => {474 const collection = await createCollectionExpectSuccess({mode: mode});475 476 await expect(executeTransaction(477 api, 478 alice, 479 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, collectionAdmin: true}}]), 480 )).to.not.be.rejected;481 482 await expect(executeTransaction(483 api, 484 alice, 485 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 486 )).to.not.be.rejected;487 488 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();489 expect(propertyRights).to.be.deep.equal([490 {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},491 ]);492 });493 }494 it('Changes access rights to properties of a NFT collection', async () => {495 await testChangesAccessRightsToProperty({type: 'NFT'});496 });497 it('Changes access rights to properties of a ReFungible collection', async function() {498 await requirePallets(this, [Pallets.ReFungible]);499500 await testChangesAccessRightsToProperty({type: 'ReFungible'});501 });502});503504describe('Negative Integration Test: Access Rights to Token Properties', () => {505 before(async () => {506 await usingApi(async (api, privateKeyWrapper) => {507 alice = privateKeyWrapper('//Alice');508 bob = privateKeyWrapper('//Bob');509 });510 });511512 async function testPreventsFromSettingAccessRightsNotAdminOrOwner(mode: CollectionMode) {513 await usingApi(async api => {514 const collection = await createCollectionExpectSuccess({mode: mode});515 516 await expect(executeTransaction(517 api, 518 bob, 519 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: true, tokenOwner: true}}]), 520 )).to.be.rejectedWith(/common\.NoPermission/);521 522 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toJSON();523 expect(propertyRights).to.be.empty;524 });525 }526 it('Prevents from setting access rights to properties of a NFT collection if not an onwer/admin', async () => {527 await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'NFT'});528 });529 it('Prevents from setting access rights to properties of a ReFungible collection if not an onwer/admin', async function() {530 await requirePallets(this, [Pallets.ReFungible]);531532 await testPreventsFromSettingAccessRightsNotAdminOrOwner({type: 'ReFungible'});533 });534535 async function testPreventFromAddingTooManyPossibleProperties(mode: CollectionMode) {536 await usingApi(async api => {537 const collection = await createCollectionExpectSuccess({mode: mode});538 539 const constitution = [];540 for (let i = 0; i < 65; i++) {541 constitution.push({542 key: 'property_' + i,543 permission: Math.random() > 0.5 ? {mutable: true, collectionAdmin: true, tokenOwner: true} : {},544 });545 }546 547 await expect(executeTransaction(548 api, 549 alice, 550 api.tx.unique.setTokenPropertyPermissions(collection, constitution), 551 )).to.be.rejectedWith(/common\.PropertyLimitReached/);552 553 const propertyRights = (await api.query.common.collectionPropertyPermissions(collection)).toJSON();554 expect(propertyRights).to.be.empty;555 }); 556 }557 it('Prevents from adding too many possible properties (NFT)', async () => {558 await testPreventFromAddingTooManyPossibleProperties({type: 'NFT'});559 });560 it('Prevents from adding too many possible properties (ReFungible)', async function() {561 await requirePallets(this, [Pallets.ReFungible]);562563 await testPreventFromAddingTooManyPossibleProperties({type: 'ReFungible'});564 });565566 async function testPreventAccessRightsModifiedIfConstant(mode: CollectionMode) {567 await usingApi(async api => {568 const collection = await createCollectionExpectSuccess({mode: mode});569 570 await expect(executeTransaction(571 api, 572 alice, 573 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {mutable: false, tokenOwner: true}}]), 574 )).to.not.be.rejected;575 576 await expect(executeTransaction(577 api, 578 alice, 579 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'skullduggery', permission: {}}]), 580 )).to.be.rejectedWith(/common\.NoPermission/);581 582 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, ['skullduggery'])).toHuman();583 expect(propertyRights).to.deep.equal([584 {key: 'skullduggery', permission: {'mutable': false, 'collectionAdmin': false, 'tokenOwner': true}},585 ]);586 }); 587 }588 it('Prevents access rights to be modified if constant (NFT)', async () => {589 await testPreventAccessRightsModifiedIfConstant({type: 'NFT'});590 });591 it('Prevents access rights to be modified if constant (ReFungible)', async function() {592 await requirePallets(this, [Pallets.ReFungible]);593594 await testPreventAccessRightsModifiedIfConstant({type: 'ReFungible'});595 });596597 async function testPreventsAddingPropertiesWithInvalidNames(mode: CollectionMode) {598 await usingApi(async api => {599 const collection = await createCollectionExpectSuccess({mode: mode});600 601 const invalidProperties = [602 [{key: 'skullduggery', permission: {tokenOwner: true}}, {key: 'im possible', permission: {collectionAdmin: true}}],603 [{key: 'G#4', permission: {tokenOwner: true}}],604 [{key: 'HÆMILTON', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}],605 ];606 607 for (let i = 0; i < invalidProperties.length; i++) {608 await expect(executeTransaction(609 api, 610 alice, 611 api.tx.unique.setTokenPropertyPermissions(collection, invalidProperties[i]), 612 ), `on setting the new badly-named property #${i}`).to.be.rejectedWith(/common\.InvalidCharacterInPropertyKey/);613 }614 615 await expect(executeTransaction(616 api, 617 alice, 618 api.tx.unique.setTokenPropertyPermissions(collection, [{key: '', permission: {}}]), 619 ), 'on rejecting an unnamed property').to.be.rejectedWith(/common\.EmptyPropertyKey/);620 621 const correctKey = '--0x03116e387820CA05'; 622 await expect(executeTransaction(623 api, 624 alice, 625 api.tx.unique.setTokenPropertyPermissions(collection, [626 {key: correctKey, permission: {collectionAdmin: true}},627 ]), 628 ), 'on setting the correctly-but-still-badly-named property').to.not.be.rejected;629 630 const keys = invalidProperties.flatMap(propertySet => propertySet.map(property => property.key)).concat(correctKey).concat('');631 632 const propertyRights = (await api.rpc.unique.propertyPermissions(collection, keys)).toHuman();633 expect(propertyRights).to.be.deep.equal([634 {key: correctKey, permission: {mutable: false, collectionAdmin: true, tokenOwner: false}},635 ]);636 });637 }638 it('Prevents adding properties with invalid names (NFT)', async () => {639 await testPreventsAddingPropertiesWithInvalidNames({type: 'NFT'});640 });641 it('Prevents adding properties with invalid names (ReFungible)', async function() {642 await requirePallets(this, [Pallets.ReFungible]);643644 await testPreventsAddingPropertiesWithInvalidNames({type: 'ReFungible'});645 });646});647648649650describe('Integration Test: Token Properties', () => {651 let permissions: {permission: any, signers: IKeyringPair[]}[];652653 before(async () => {654 await usingApi(async (api, privateKeyWrapper) => {655 alice = privateKeyWrapper('//Alice'); 656 bob = privateKeyWrapper('//Bob'); 657 charlie = privateKeyWrapper('//Charlie'); 658659 permissions = [660 {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob]},661 {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob]},662 {permission: {mutable: true, tokenOwner: true}, signers: [charlie]},663 {permission: {mutable: false, tokenOwner: true}, signers: [charlie]},664 {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},665 {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie]},666 ];667 });668 });669 670 async function testReadsYetEmptyProperties(mode: CollectionMode) {671 await usingApi(async api => {672 const collection = await createCollectionExpectSuccess({mode: mode});673 const token = await createItemExpectSuccess(alice, collection, mode.type);674 675 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();676 expect(properties.map).to.be.empty;677 expect(properties.consumedSpace).to.be.equal(0);678 679 const tokenData = (await api.rpc.unique.tokenData(collection, token, ['anything'])).toJSON().properties;680 expect(tokenData).to.be.empty;681 });682 }683 it('Reads yet empty properties of a token (NFT)', async () => {684 await testReadsYetEmptyProperties({type: 'NFT'});685 });686 it('Reads yet empty properties of a token (ReFungible)', async function() {687 await requirePallets(this, [Pallets.ReFungible]);688689 await testReadsYetEmptyProperties({type: 'ReFungible'});690 });691692 async function testAssignPropertiesAccordingToPermissions(mode: CollectionMode, pieces: number) {693 await usingApi(async api => {694 const collection = await createCollectionExpectSuccess({mode: mode});695 const token = await createItemExpectSuccess(alice, collection, mode.type);696 await addCollectionAdminExpectSuccess(alice, collection, bob.address);697 await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);698699 const propertyKeys: string[] = [];700 let i = 0;701 for (const permission of permissions) {702 for (const signer of permission.signers) {703 const key = i + '_' + signer.address;704 propertyKeys.push(key);705706 await expect(executeTransaction(707 api, 708 alice, 709 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 710 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;711712 await expect(executeTransaction(713 api, 714 signer, 715 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 716 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;717 }718719 i++;720 }721722 const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];723 const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];724 for (let i = 0; i < properties.length; i++) {725 expect(properties[i].value).to.be.equal('Serotonin increase');726 expect(tokensData[i].value).to.be.equal('Serotonin increase');727 }728 });729 }730 it('Assigns properties to a token according to permissions (NFT)', async () => {731 await testAssignPropertiesAccordingToPermissions({type: 'NFT'}, 1);732 });733 it('Assigns properties to a token according to permissions (ReFungible)', async function() {734 await requirePallets(this, [Pallets.ReFungible]);735736 await testAssignPropertiesAccordingToPermissions({type: 'ReFungible'}, 100);737 });738739 async function testChangesPropertiesAccordingPermission(mode: CollectionMode, pieces: number) {740 await usingApi(async api => {741 const collection = await createCollectionExpectSuccess({mode: mode});742 const token = await createItemExpectSuccess(alice, collection, mode.type);743 await addCollectionAdminExpectSuccess(alice, collection, bob.address);744 await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);745746 const propertyKeys: string[] = [];747 let i = 0;748 for (const permission of permissions) {749 if (!permission.permission.mutable) continue;750 751 for (const signer of permission.signers) {752 const key = i + '_' + signer.address;753 propertyKeys.push(key);754 755 await expect(executeTransaction(756 api, 757 alice, 758 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 759 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;760 761 await expect(executeTransaction(762 api, 763 signer, 764 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 765 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;766 767 await expect(executeTransaction(768 api, 769 signer, 770 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin stable'}]), 771 ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;772 }773 774 i++;775 }776 777 const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toHuman() as any[];778 const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toHuman().properties as any[];779 for (let i = 0; i < properties.length; i++) {780 expect(properties[i].value).to.be.equal('Serotonin stable');781 expect(tokensData[i].value).to.be.equal('Serotonin stable');782 }783 });784 }785 it('Changes properties of a token according to permissions (NFT)', async () => {786 await testChangesPropertiesAccordingPermission({type: 'NFT'}, 1);787 });788 it('Changes properties of a token according to permissions (ReFungible)', async function() {789 await requirePallets(this, [Pallets.ReFungible]);790791 await testChangesPropertiesAccordingPermission({type: 'ReFungible'}, 100);792 });793794 async function testDeletePropertiesAccordingPermission(mode: CollectionMode, pieces: number) {795 await usingApi(async api => {796 const collection = await createCollectionExpectSuccess({mode: mode});797 const token = await createItemExpectSuccess(alice, collection, mode.type);798 await addCollectionAdminExpectSuccess(alice, collection, bob.address);799 await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);800801 const propertyKeys: string[] = [];802 let i = 0;803 804 for (const permission of permissions) {805 if (!permission.permission.mutable) continue;806 807 for (const signer of permission.signers) {808 const key = i + '_' + signer.address;809 propertyKeys.push(key);810 811 await expect(executeTransaction(812 api, 813 alice, 814 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 815 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;816 817 await expect(executeTransaction(818 api, 819 signer, 820 api.tx.unique.setTokenProperties(collection, token, [{key: key, value: 'Serotonin increase'}]), 821 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;822 823 await expect(executeTransaction(824 api, 825 signer, 826 api.tx.unique.deleteTokenProperties(collection, token, [key]), 827 ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;828 }829 830 i++;831 }832 833 const properties = (await api.rpc.unique.tokenProperties(collection, token, propertyKeys)).toJSON() as any[];834 expect(properties).to.be.empty;835 const tokensData = (await api.rpc.unique.tokenData(collection, token, propertyKeys)).toJSON().properties as any[];836 expect(tokensData).to.be.empty;837 expect((await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace).to.be.equal(0);838 });839 }840 it('Deletes properties of a token according to permissions (NFT)', async () => {841 await testDeletePropertiesAccordingPermission({type: 'NFT'}, 1);842 });843 it('Deletes properties of a token according to permissions (ReFungible)', async function() {844 await requirePallets(this, [Pallets.ReFungible]);845846 await testDeletePropertiesAccordingPermission({type: 'ReFungible'}, 100);847 });848849 it('Assigns properties to a nested token according to permissions', async () => {850 await usingApi(async api => {851 const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});852 await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});853 const token = await createItemExpectSuccess(alice, collection, 'NFT');854 const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});855 await addCollectionAdminExpectSuccess(alice, collection, bob.address);856 await transferExpectSuccess(collection, token, alice, charlie);857858 const propertyKeys: string[] = [];859 let i = 0;860 for (const permission of permissions) {861 for (const signer of permission.signers) {862 const key = i + '_' + signer.address;863 propertyKeys.push(key);864865 await expect(executeTransaction(866 api, 867 alice, 868 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 869 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;870871 await expect(executeTransaction(872 api, 873 signer, 874 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 875 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;876 }877878 i++;879 }880881 const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];882 const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];883 for (let i = 0; i < properties.length; i++) {884 expect(properties[i].value).to.be.equal('Serotonin increase');885 expect(tokensData[i].value).to.be.equal('Serotonin increase');886 }887 });888 });889890 it('Changes properties of a nested token according to permissions', async () => {891 await usingApi(async api => {892 const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});893 await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});894 const token = await createItemExpectSuccess(alice, collection, 'NFT');895 const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});896 await addCollectionAdminExpectSuccess(alice, collection, bob.address);897 await transferExpectSuccess(collection, token, alice, charlie);898899 const propertyKeys: string[] = [];900 let i = 0;901 for (const permission of permissions) {902 if (!permission.permission.mutable) continue;903 904 for (const signer of permission.signers) {905 const key = i + '_' + signer.address;906 propertyKeys.push(key);907908 await expect(executeTransaction(909 api, 910 alice, 911 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 912 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;913914 await expect(executeTransaction(915 api, 916 signer, 917 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 918 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;919920 await expect(executeTransaction(921 api, 922 signer, 923 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin stable'}]), 924 ), `on changing property ${i} by ${signer.address}`).to.not.be.rejected;925 }926927 i++;928 }929930 const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toHuman() as any[];931 const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toHuman().properties as any[];932 for (let i = 0; i < properties.length; i++) {933 expect(properties[i].value).to.be.equal('Serotonin stable');934 expect(tokensData[i].value).to.be.equal('Serotonin stable');935 }936 });937 });938939 it('Deletes properties of a nested token according to permissions', async () => {940 await usingApi(async api => {941 const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});942 await setCollectionPermissionsExpectSuccess(alice, collection, {nesting: {tokenOwner: true}});943 const token = await createItemExpectSuccess(alice, collection, 'NFT');944 const nestedToken = await createItemExpectSuccess(alice, collection, 'NFT', {Ethereum: tokenIdToAddress(collection, token)});945 await addCollectionAdminExpectSuccess(alice, collection, bob.address);946 await transferExpectSuccess(collection, token, alice, charlie);947948 const propertyKeys: string[] = [];949 let i = 0;950951 for (const permission of permissions) {952 if (!permission.permission.mutable) continue;953 954 for (const signer of permission.signers) {955 const key = i + '_' + signer.address;956 propertyKeys.push(key);957958 await expect(executeTransaction(959 api, 960 alice, 961 api.tx.unique.setTokenPropertyPermissions(collection, [{key: key, permission: permission.permission}]), 962 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;963964 await expect(executeTransaction(965 api, 966 signer, 967 api.tx.unique.setTokenProperties(collection, nestedToken, [{key: key, value: 'Serotonin increase'}]), 968 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;969970 await expect(executeTransaction(971 api, 972 signer, 973 api.tx.unique.deleteTokenProperties(collection, nestedToken, [key]), 974 ), `on deleting property ${i} by ${signer.address}`).to.not.be.rejected;975 }976 977 i++;978 }979980 const properties = (await api.rpc.unique.tokenProperties(collection, nestedToken, propertyKeys)).toJSON() as any[];981 expect(properties).to.be.empty;982 const tokensData = (await api.rpc.unique.tokenData(collection, nestedToken, propertyKeys)).toJSON().properties as any[];983 expect(tokensData).to.be.empty;984 expect((await api.query.nonfungible.tokenProperties(collection, nestedToken)).toJSON().consumedSpace).to.be.equal(0);985 });986 });987});988989describe('Negative Integration Test: Token Properties', () => {990 let collection: number;991 let token: number;992 let originalSpace: number;993 let constitution: {permission: any, signers: IKeyringPair[], sinner: IKeyringPair}[];994995 before(async () => {996 await usingApi(async (api, privateKeyWrapper) => {997 alice = privateKeyWrapper('//Alice');998 bob = privateKeyWrapper('//Bob');999 charlie = privateKeyWrapper('//Charlie');1000 const dave = privateKeyWrapper('//Dave');10011002 constitution = [1003 {permission: {mutable: true, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},1004 {permission: {mutable: false, collectionAdmin: true}, signers: [alice, bob], sinner: charlie},1005 {permission: {mutable: true, tokenOwner: true}, signers: [charlie], sinner: alice},1006 {permission: {mutable: false, tokenOwner: true}, signers: [charlie], sinner: alice},1007 {permission: {mutable: true, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},1008 {permission: {mutable: false, collectionAdmin: true, tokenOwner: true}, signers: [alice, bob, charlie], sinner: dave},1009 ];1010 });1011 });10121013 async function prepare(mode: CollectionMode, pieces: number) {1014 collection = await createCollectionExpectSuccess({mode: mode});1015 token = await createItemExpectSuccess(alice, collection, mode.type);1016 await addCollectionAdminExpectSuccess(alice, collection, bob.address);1017 await transferExpectSuccess(collection, token, alice, charlie, pieces, mode.type);1018 1019 await usingApi(async api => {1020 let i = 0;1021 for (const passage of constitution) {1022 const signer = passage.signers[0];1023 1024 await expect(executeTransaction(1025 api, 1026 alice, 1027 api.tx.unique.setTokenPropertyPermissions(collection, [{key: `${i}`, permission: passage.permission}]), 1028 ), `on setting permission ${i} by ${signer.address}`).to.not.be.rejected;1029 1030 await expect(executeTransaction(1031 api, 1032 signer, 1033 api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin increase'}]), 1034 ), `on adding property ${i} by ${signer.address}`).to.not.be.rejected;1035 1036 i++;1037 }1038 1039 originalSpace = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON().consumedSpace as number;1040 }); 1041 }10421043 async function testForbidsChangingDeletingPropertiesUserOutsideOfPermissions(mode: CollectionMode, pieces: number) {1044 await prepare(mode, pieces);1045 1046 await usingApi(async api => {1047 let i = -1;1048 for (const forbiddance of constitution) {1049 i++;1050 if (!forbiddance.permission.mutable) continue;1051 1052 await expect(executeTransaction(1053 api, 1054 forbiddance.sinner, 1055 api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 1056 ), `on failing to change property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);1057 1058 await expect(executeTransaction(1059 api, 1060 forbiddance.sinner, 1061 api.tx.unique.deleteTokenProperties(collection, token, [`${i}`]), 1062 ), `on failing to delete property ${i} by ${forbiddance.sinner.address}`).to.be.rejectedWith(/common\.NoPermission/);1063 }1064 1065 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();1066 expect(properties.consumedSpace).to.be.equal(originalSpace);1067 });1068 }1069 it('Forbids changing/deleting properties of a token if the user is outside of permissions (NFT)', async () => {1070 await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions({type: 'NFT'}, 1);1071 });1072 it('Forbids changing/deleting properties of a token if the user is outside of permissions (ReFungible)', async function() {1073 await requirePallets(this, [Pallets.ReFungible]);10741075 await testForbidsChangingDeletingPropertiesUserOutsideOfPermissions({type: 'ReFungible'}, 100);1076 });10771078 async function testForbidsChangingDeletingPropertiesIfPropertyImmutable(mode: CollectionMode, pieces: number) {1079 await prepare(mode, pieces);1080 1081 await usingApi(async api => {1082 let i = -1;1083 for (const permission of constitution) {1084 i++;1085 if (permission.permission.mutable) continue;1086 1087 await expect(executeTransaction(1088 api, 1089 permission.signers[0], 1090 api.tx.unique.setTokenProperties(collection, token, [{key: `${i}`, value: 'Serotonin down'}]), 1091 ), `on failing to change property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);1092 1093 await expect(executeTransaction(1094 api, 1095 permission.signers[0], 1096 api.tx.unique.deleteTokenProperties(collection, token, [i.toString()]), 1097 ), `on failing to delete property ${i} by ${permission.signers[0].address}`).to.be.rejectedWith(/common\.NoPermission/);1098 }1099 1100 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();1101 expect(properties.consumedSpace).to.be.equal(originalSpace);1102 }); 1103 }1104 it('Forbids changing/deleting properties of a token if the property is permanent (immutable) (NFT)', async () => {1105 await testForbidsChangingDeletingPropertiesIfPropertyImmutable({type: 'NFT'}, 1);1106 });1107 it('Forbids changing/deleting properties of a token if the property is permanent (immutable) (ReFungible)', async function() {1108 await requirePallets(this, [Pallets.ReFungible]);11091110 await testForbidsChangingDeletingPropertiesIfPropertyImmutable({type: 'ReFungible'}, 100);1111 });11121113 async function testForbidsAddingPropertiesIfPropertyNotDeclared(mode: CollectionMode, pieces: number) {1114 await prepare(mode, pieces);11151116 await usingApi(async api => {1117 await expect(executeTransaction(1118 api, 1119 alice, 1120 api.tx.unique.setTokenProperties(collection, token, [{key: 'non-existent', value: 'I exist!'}]), 1121 ), 'on failing to add a previously non-existent property').to.be.rejectedWith(/common\.NoPermission/);1122 1123 await expect(executeTransaction(1124 api, 1125 alice, 1126 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'now-existent', permission: {}}]), 1127 ), 'on setting a new non-permitted property').to.not.be.rejected;1128 1129 await expect(executeTransaction(1130 api, 1131 alice, 1132 api.tx.unique.setTokenProperties(collection, token, [{key: 'now-existent', value: 'I exist!'}]), 1133 ), 'on failing to add a property forbidden by the \'None\' permission').to.be.rejectedWith(/common\.NoPermission/);1134 1135 expect((await api.rpc.unique.tokenProperties(collection, token, ['non-existent', 'now-existent'])).toJSON()).to.be.empty;1136 const properties = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();1137 expect(properties.consumedSpace).to.be.equal(originalSpace);1138 });1139 }1140 it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (NFT)', async () => {1141 await testForbidsAddingPropertiesIfPropertyNotDeclared({type: 'NFT'}, 1);1142 });1143 it('Forbids adding properties to a token if the property is not declared / forbidden with the \'None\' permission (ReFungible)', async function() {1144 await requirePallets(this, [Pallets.ReFungible]);11451146 await testForbidsAddingPropertiesIfPropertyNotDeclared({type: 'ReFungible'}, 100);1147 });11481149 async function testForbidsAddingTooManyProperties(mode: CollectionMode, pieces: number) {1150 await prepare(mode, pieces);11511152 await usingApi(async api => {1153 await expect(executeTransaction(1154 api, 1155 alice, 1156 api.tx.unique.setTokenPropertyPermissions(collection, [1157 {key: 'a_holy_book', permission: {collectionAdmin: true, tokenOwner: true}}, 1158 {key: 'young_years', permission: {collectionAdmin: true, tokenOwner: true}},1159 ]), 1160 ), 'on setting a new non-permitted property').to.not.be.rejected;1161 1162 1163 {1164 console.error = () => {};1165 await expect(executeTransaction(1166 api, 1167 alice, 1168 api.tx.unique.setCollectionProperties(collection, [{key: 'a_holy_book', value: 'word '.repeat(6554)}]), 1169 )).to.be.rejected;1170 }1171 1172 await expect(executeTransaction(1173 api, 1174 alice, 1175 api.tx.unique.setTokenProperties(collection, token, [1176 {key: 'a_holy_book', value: 'word '.repeat(3277)}, 1177 {key: 'young_years', value: 'neverending'.repeat(1490)},1178 ]), 1179 )).to.be.rejectedWith(/common\.NoSpaceForProperty/);1180 1181 expect((await api.rpc.unique.tokenProperties(collection, token, ['a_holy_book', 'young_years'])).toJSON()).to.be.empty;1182 const propertiesMap = (await api.query.nonfungible.tokenProperties(collection, token)).toJSON();1183 expect(propertiesMap.consumedSpace).to.be.equal(originalSpace);1184 });1185 }1186 it('Forbids adding too many properties to a token (NFT)', async () => {1187 await testForbidsAddingTooManyProperties({type: 'NFT'}, 1);1188 });1189 it('Forbids adding too many properties to a token (ReFungible)', async function() {1190 await requirePallets(this, [Pallets.ReFungible]);11911192 await testForbidsAddingTooManyProperties({type: 'ReFungible'}, 100);1193 });1194});11951196describe('ReFungible token properties permissions tests', () => {1197 let collection: number;1198 let token: number;11991200 before(async function() {1201 await requirePallets(this, [Pallets.ReFungible]);12021203 await usingApi(async (api, privateKeyWrapper) => {1204 alice = privateKeyWrapper('//Alice');1205 bob = privateKeyWrapper('//Bob');1206 charlie = privateKeyWrapper('//Charlie');1207 });1208 });12091210 beforeEach(async () => {1211 await usingApi(async api => {1212 collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});1213 token = await createItemExpectSuccess(alice, collection, 'ReFungible');1214 await addCollectionAdminExpectSuccess(alice, collection, bob.address);12151216 await expect(executeTransaction(1217 api, 1218 alice, 1219 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'key', permission: {mutable:true, tokenOwner: true}}]), 1220 )).to.not.be.rejected;1221 });1222 });12231224 it('Forbids add token property with tokenOwher==true but signer have\'t all pieces', async () => {1225 await usingApi(async api => {1226 await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');1227 1228 await expect(executeTransaction(1229 api, 1230 alice, 1231 api.tx.unique.setTokenProperties(collection, token, [1232 {key: 'key', value: 'word'}, 1233 ]), 1234 )).to.be.rejectedWith(/common\.NoPermission/);1235 });1236 });12371238 it('Forbids mutate token property with tokenOwher==true but signer have\'t all pieces', async () => {1239 await usingApi(async api => {1240 await expect(executeTransaction(1241 api, 1242 alice, 1243 api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'key', permission: {mutable:true, tokenOwner: true}}]), 1244 )).to.not.be.rejected;1245 1246 await expect(executeTransaction(1247 api, 1248 alice, 1249 api.tx.unique.setTokenProperties(collection, token, [1250 {key: 'key', value: 'word'}, 1251 ]), 1252 )).to.be.not.rejected;12531254 await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');1255 1256 await expect(executeTransaction(1257 api, 1258 alice, 1259 api.tx.unique.setTokenProperties(collection, token, [1260 {key: 'key', value: 'bad word'}, 1261 ]), 1262 )).to.be.rejectedWith(/common\.NoPermission/);1263 });1264 });12651266 it('Forbids delete token property with tokenOwher==true but signer have\'t all pieces', async () => {1267 await usingApi(async api => {1268 await expect(executeTransaction(1269 api, 1270 alice, 1271 api.tx.unique.setTokenProperties(collection, token, [1272 {key: 'key', value: 'word'}, 1273 ]), 1274 )).to.be.not.rejected;12751276 await transferExpectSuccess(collection, token, alice, charlie, 33, 'ReFungible');1277 1278 await expect(executeTransaction(1279 api, 1280 alice, 1281 api.tx.unique.deleteTokenProperties(collection, token, [1282 'key',1283 ]), 1284 )).to.be.rejectedWith(/common\.NoPermission/);1285 });1286 });1287});