difftreelog
Merge pull request #596 from UniqueNetwork/test/playground-migration
in: master
Test/playground migration
15 files changed
tests/package.jsondiffbeforeafterboth--- a/tests/package.json
+++ b/tests/package.json
@@ -44,6 +44,7 @@
"testAddCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/addCollectionAdmin.test.ts",
"testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts",
"testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts",
+ "testChangeCollectionOwner": "mocha --timeout 9999999 -r ts-node/register ./**/change-collection-owner.test.ts",
"testSetCollectionSponsor": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionSponsor.test.ts",
"testConfirmSponsorship": "mocha --timeout 9999999 -r ts-node/register ./**/confirmSponsorship.test.ts",
"testRemoveCollectionAdmin": "mocha --timeout 9999999 -r ts-node/register ./**/removeCollectionAdmin.test.ts",
tests/src/adminTransferAndBurn.test.tsdiffbeforeafterboth--- a/tests/src/adminTransferAndBurn.test.ts
+++ b/tests/src/adminTransferAndBurn.test.ts
@@ -15,14 +15,7 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {usingPlaygrounds} from './util/playgrounds';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
-
-let donor: IKeyringPair;
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
describe('Integration Test: ownerCanTransfer allows admins to use only transferFrom/burnFrom:', () => {
let alice: IKeyringPair;
@@ -31,44 +24,40 @@
before(async () => {
await usingPlaygrounds(async (helper, privateKey) => {
- donor = privateKey('//Alice');
+ const donor = privateKey('//Alice');
[alice, bob, charlie] = await helper.arrange.createAccounts([10n, 10n, 10n], donor);
});
});
- it('admin transfers other user\'s token', async () => {
- await usingPlaygrounds(async (helper) => {
- const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
- await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
- const limits = await helper.collection.getEffectiveLimits(collectionId);
- expect(limits.ownerCanTransfer).to.be.true;
+ itSub('admin transfers other user\'s token', async ({helper}) => {
+ const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+ await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
+ const limits = await helper.collection.getEffectiveLimits(collectionId);
+ expect(limits.ownerCanTransfer).to.be.true;
- const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
- const transferResult = async () => helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
- await expect(transferResult()).to.be.rejected;
+ const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
+ const transferResult = async () => helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
+ await expect(transferResult()).to.be.rejected;
- await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});
- const newTokenOwner = await helper.nft.getTokenOwner(collectionId, tokenId);
- expect(newTokenOwner.Substrate).to.be.equal(charlie.address);
- });
+ await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address});
+ const newTokenOwner = await helper.nft.getTokenOwner(collectionId, tokenId);
+ expect(newTokenOwner.Substrate).to.be.equal(charlie.address);
});
- it('admin burns other user\'s token', async () => {
- await usingPlaygrounds(async (helper) => {
- const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+ itSub('admin burns other user\'s token', async ({helper}) => {
+ const {collectionId} = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
- await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
- const limits = await helper.collection.getEffectiveLimits(collectionId);
- expect(limits.ownerCanTransfer).to.be.true;
+ await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: true});
+ const limits = await helper.collection.getEffectiveLimits(collectionId);
+ expect(limits.ownerCanTransfer).to.be.true;
- const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
- const burnTxFailed = async () => helper.nft.burnToken(alice, collectionId, tokenId);
+ const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address});
+ const burnTxFailed = async () => helper.nft.burnToken(alice, collectionId, tokenId);
- await expect(burnTxFailed()).to.be.rejected;
+ await expect(burnTxFailed()).to.be.rejected;
- await helper.nft.burnToken(bob, collectionId, tokenId);
- const token = await helper.nft.getToken(collectionId, tokenId);
- expect(token).to.be.null;
- });
+ await helper.nft.burnToken(bob, collectionId, tokenId);
+ const token = await helper.nft.getToken(collectionId, tokenId);
+ expect(token).to.be.null;
});
});
tests/src/allowLists.test.tsdiffbeforeafterboth--- a/tests/src/allowLists.test.ts
+++ b/tests/src/allowLists.test.ts
@@ -18,7 +18,7 @@
import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
import {ICollectionPermissions} from './util/playgrounds/types';
-describe('Integration Test ext. Add to Allow List', () => {
+describe('Integration Test ext. Allow list tests', () => {
let alice: IKeyringPair;
let bob: IKeyringPair;
let charlie: IKeyringPair;
@@ -38,7 +38,7 @@
const allowList = await helper.nft.getAllowList(collectionId);
expect(allowList).to.deep.contain({Substrate: bob.address});
});
-
+
itSub('Admin can add address to allow list', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
await helper.nft.addAdmin(alice, collectionId, {Substrate: bob.address});
@@ -64,7 +64,7 @@
await expect(helper.nft.addToAllowList(bob, collectionId, {Substrate: charlie.address}))
.to.be.rejectedWith(/common\.CollectionNotFound/);
});
-
+
itSub('Nobody can add address to allow list of destroyed collection', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
await helper.collection.burn(alice, collectionId);
@@ -80,7 +80,7 @@
});
});
-describe('Integration Test ext. Remove from Allow List', () => {
+describe('Integration Test ext. Remove from Allow List', () => {
let alice: IKeyringPair;
let bob: IKeyringPair;
let charlie: IKeyringPair;
@@ -120,9 +120,9 @@
await helper.collection.removeFromAllowList(alice, collectionId, {Substrate: bob.address});
const allowListBefore = await helper.nft.getAllowList(collectionId);
expect(allowListBefore).to.not.deep.contain({Substrate: bob.address});
-
+
await helper.collection.removeFromAllowList(alice, collectionId, {Substrate: bob.address});
-
+
const allowListAfter = await helper.nft.getAllowList(collectionId);
expect(allowListAfter).to.not.deep.contain({Substrate: bob.address});
});
@@ -138,25 +138,25 @@
const allowList = await helper.nft.getAllowList(collectionId);
expect(allowList).to.deep.contain({Substrate: charlie.address});
});
-
+
itSub('Nobody can remove address from allow list of non-existing collection', async ({helper}) => {
const collectionId = (1<<32) - 1;
await expect(helper.collection.removeFromAllowList(bob, collectionId, {Substrate: charlie.address}))
.to.be.rejectedWith(/common\.CollectionNotFound/);
});
-
+
itSub('Nobody can remove address from allow list of deleted collection', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
await helper.nft.addToAllowList(alice, collectionId, {Substrate: bob.address});
await helper.collection.burn(alice, collectionId);
-
+
await expect(helper.collection.removeFromAllowList(alice, collectionId, {Substrate: bob.address}))
.to.be.rejectedWith(/common\.CollectionNotFound/);
});
});
});
-describe('Integration Test ext. Transfer if included in Allow List', () => {
+describe('Integration Test ext. Transfer if included in Allow List', () => {
let alice: IKeyringPair;
let bob: IKeyringPair;
let charlie: IKeyringPair;
@@ -179,7 +179,7 @@
const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
expect(owner.Substrate).to.be.equal(charlie.address);
});
-
+
itSub('If Public Access mode is set to AllowList, tokens can be transferred to a allowlisted address with transferFrom.', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -187,24 +187,24 @@
await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
-
+
await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: alice.address}, {Substrate: charlie.address});
const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
expect(owner.Substrate).to.be.equal(charlie.address);
});
-
+
itSub('If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transfer', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
await helper.nft.setPermissions(alice, collectionId, {access: 'AllowList'});
await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
-
+
await helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address});
const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
expect(owner.Substrate).to.be.equal(charlie.address);
});
-
+
itSub('If Public Access mode is set to AllowList, tokens can be transferred from a allowlisted address with transferFrom', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -212,7 +212,7 @@
await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
-
+
await helper.nft.transferTokenFrom(alice, collectionId, tokenId, {Substrate: alice.address}, {Substrate: charlie.address});
const owner = await helper.nft.getTokenOwner(collectionId, tokenId);
expect(owner.Substrate).to.be.equal(charlie.address);
@@ -225,11 +225,11 @@
const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
await helper.nft.setPermissions(alice, collectionId, {access: 'AllowList'});
await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
-
+
await expect(helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address}))
.to.be.rejectedWith(/common\.AddressNotInAllowlist/);
});
-
+
itSub('If Public Access mode is set to AllowList, tokens can\'t be transferred from a non-allowlisted address with transfer or transferFrom. Test2', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -238,35 +238,35 @@
await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
await helper.collection.removeFromAllowList(alice, collectionId, {Substrate: alice.address});
-
+
await expect(helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address}))
.to.be.rejectedWith(/common\.AddressNotInAllowlist/);
});
-
+
itSub('If Public Access mode is set to AllowList, tokens can\'t be transferred to a non-allowlisted address with transfer or transferFrom. Test1', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
await helper.nft.setPermissions(alice, collectionId, {access: 'AllowList'});
await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
-
+
await expect(helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address}))
.to.be.rejectedWith(/common\.AddressNotInAllowlist/);
});
-
+
itSub('If Public Access mode is set to AllowList, tokens can\'t be transferred to a non-allowlisted address with transfer or transferFrom. Test2', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
await helper.nft.setPermissions(alice, collectionId, {access: 'AllowList'});
await helper.nft.addToAllowList(alice, collectionId, {Substrate: alice.address});
await helper.nft.addToAllowList(alice, collectionId, {Substrate: charlie.address});
-
+
await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address});
await helper.collection.removeFromAllowList(alice, collectionId, {Substrate: alice.address});
-
+
await expect(helper.nft.transferToken(alice, collectionId, tokenId, {Substrate: charlie.address}))
.to.be.rejectedWith(/common\.AddressNotInAllowlist/);
});
-
+
itSub('If Public Access mode is set to AllowList, tokens can\'t be destroyed by a non-allowlisted address (even if it owned them before enabling AllowList mode)', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -274,7 +274,7 @@
await expect(helper.nft.burnToken(bob, collectionId, tokenId))
.to.be.rejectedWith(/common\.NoPermission/);
});
-
+
itSub('If Public Access mode is set to AllowList, token transfers can\'t be Approved by a non-allowlisted address (see Approve method)', async ({helper}) => {
const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address});
@@ -285,7 +285,7 @@
});
});
-describe('Integration Test ext. Mint if included in Allow List', () => {
+describe('Integration Test ext. Mint if included in Allow List', () => {
let alice: IKeyringPair;
let bob: IKeyringPair;
@@ -309,7 +309,7 @@
const appropriateRejectionMessage = permissions.mintMode! ? /common\.AddressNotInAllowlist/ : /common\.PublicMintingNotAllowed/;
const allowlistedMintingTest = () => itSub(
- `With the condtions above, tokens can${allowlistedMintingShouldFail ? '\'t' : ''} be created by allow-listed addresses`,
+ `With the condtions above, tokens can${allowlistedMintingShouldFail ? '\'t' : ''} be created by allow-listed addresses`,
async ({helper}) => {
const collection = await helper.nft.mintCollection(alice, {});
await collection.setPermissions(alice, permissions);
@@ -330,7 +330,7 @@
await collection.setPermissions(alice, permissions);
await expect(collection.mintToken(alice, {Substrate: alice.address})).to.not.be.rejected;
});
-
+
itSub('With the condtions above, tokens can be created by admin', async ({helper}) => {
const collection = await helper.nft.mintCollection(alice, {});
await collection.setPermissions(alice, permissions);
tests/src/change-collection-owner.test.tsdiffbeforeafterboth--- a/tests/src/change-collection-owner.test.ts
+++ b/tests/src/change-collection-owner.test.ts
@@ -14,231 +14,156 @@
// You should have received a copy of the GNU General Public License
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
-import {createCollectionExpectSuccess,
- addCollectionAdminExpectSuccess,
- setCollectionSponsorExpectSuccess,
- confirmSponsorshipExpectSuccess,
- removeCollectionSponsorExpectSuccess,
- enableAllowListExpectSuccess,
- setMintPermissionExpectSuccess,
- destroyCollectionExpectSuccess,
- setCollectionSponsorExpectFailure,
- confirmSponsorshipExpectFailure,
- removeCollectionSponsorExpectFailure,
- enableAllowListExpectFail,
- setMintPermissionExpectFailure,
- destroyCollectionExpectFailure,
- setPublicAccessModeExpectSuccess,
- queryCollectionExpectSuccess,
-} from './util/helpers';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {IKeyringPair} from '@polkadot/types/types';
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
describe('Integration Test changeCollectionOwner(collection_id, new_owner):', () => {
- it('Changing owner changes owner address', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const collectionId = await createCollectionExpectSuccess();
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
- const collection =await queryCollectionExpectSuccess(api, collectionId);
- expect(collection.owner.toString()).to.be.deep.eq(alice.address);
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
+ });
+ });
- const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
- await submitTransactionAsync(alice, changeOwnerTx);
+ itSub('Changing owner changes owner address', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const beforeChanging = await helper.collection.getData(collection.collectionId);
+ expect(beforeChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(alice.address));
- const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
- expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
- });
+ await collection.changeOwner(alice, bob.address);
+ const afterChanging = await helper.collection.getData(collection.collectionId);
+ expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
});
});
describe('Integration Test changeCollectionOwner(collection_id, new_owner) special checks for exOwner:', () => {
- it('Changing the owner of the collection is not allowed for the former owner', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const collectionId = await createCollectionExpectSuccess();
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+ let charlie: IKeyringPair;
- const collection = await queryCollectionExpectSuccess(api, collectionId);
- expect(collection.owner.toString()).to.be.deep.eq(alice.address);
-
- const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
- await submitTransactionAsync(alice, changeOwnerTx);
-
- const badChangeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, alice.address);
- await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;
-
- const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
- expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
});
});
-
- it('New collectionOwner has access to sponsorship management operations in the collection', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const collectionId = await createCollectionExpectSuccess();
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- const collection = await queryCollectionExpectSuccess(api, collectionId);
- expect(collection.owner.toString()).to.be.deep.eq(alice.address);
-
- const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
- await submitTransactionAsync(alice, changeOwnerTx);
-
- const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
- expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
+ itSub('Changing the owner of the collection is not allowed for the former owner', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
- // After changing the owner of the collection, all privileged methods are available to the new owner
- // The new owner of the collection has access to sponsorship management operations in the collection
- await setCollectionSponsorExpectSuccess(collectionId, charlie.address, '//Bob');
- await confirmSponsorshipExpectSuccess(collectionId, '//Charlie');
- await removeCollectionSponsorExpectSuccess(collectionId, '//Bob');
+ await collection.changeOwner(alice, bob.address);
- // The new owner of the collection has access to operations for managing the collection parameters
- const collectionLimits = {
- accountTokenOwnershipLimit: 1,
- sponsoredMintSize: 1,
- tokenLimit: 1,
- sponsorTransferTimeout: 1,
- ownerCanTransfer: true,
- ownerCanDestroy: true,
- };
- const tx1 = api.tx.unique.setCollectionLimits(
- collectionId,
- collectionLimits,
- );
- await submitTransactionAsync(bob, tx1);
+ const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+ await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
- await setPublicAccessModeExpectSuccess(bob, collectionId, 'AllowList');
- await enableAllowListExpectSuccess(bob, collectionId);
- await setMintPermissionExpectSuccess(bob, collectionId, true);
- await destroyCollectionExpectSuccess(collectionId, '//Bob');
- });
+ const afterChanging = await helper.collection.getData(collection.collectionId);
+ expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
});
- it('New collectionOwner has access to changeCollectionOwner', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const collectionId = await createCollectionExpectSuccess();
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
+ itSub('New collectionOwner has access to sponsorship management operations in the collection', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.changeOwner(alice, bob.address);
- const collection = await queryCollectionExpectSuccess(api, collectionId);
- expect(collection.owner.toString()).to.be.deep.eq(alice.address);
+ const afterChanging = await helper.collection.getData(collection.collectionId);
+ expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
- const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
- await submitTransactionAsync(alice, changeOwnerTx);
+ await collection.setSponsor(bob, charlie.address);
+ await collection.confirmSponsorship(charlie);
+ await collection.removeSponsor(bob);
+ const limits = {
+ accountTokenOwnershipLimit: 1,
+ tokenLimit: 1,
+ sponsorTransferTimeout: 1,
+ ownerCanDestroy: true,
+ ownerCanTransfer: true,
+ };
- const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
- expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
+ await collection.setLimits(bob, limits);
+ const gotLimits = await collection.getEffectiveLimits();
+ expect(gotLimits).to.be.deep.contains(limits);
- const changeOwnerTx2 = api.tx.unique.changeCollectionOwner(collectionId, charlie.address);
- await submitTransactionAsync(bob, changeOwnerTx2);
+ await collection.setPermissions(bob, {access: 'AllowList', mintMode: true});
- // ownership lost
- const collectionAfterOwnerChange2 = await queryCollectionExpectSuccess(api, collectionId);
- expect(collectionAfterOwnerChange2.owner.toString()).to.be.deep.eq(charlie.address);
- });
+ await collection.burn(bob);
+ const collectionData = await helper.collection.getData(collection.collectionId);
+ expect(collectionData).to.be.null;
});
+
+ itSub('New collectionOwner has access to changeCollectionOwner', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.changeOwner(alice, bob.address);
+ await collection.changeOwner(bob, charlie.address);
+ const collectionData = await collection.getData();
+ expect(collectionData?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(charlie.address));
+ });
});
describe('Negative Integration Test changeCollectionOwner(collection_id, new_owner):', () => {
- it('Not owner can\'t change owner.', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const collectionId = await createCollectionExpectSuccess();
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
-
- const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
- await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;
-
- const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
- expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(alice.address);
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+ let charlie: IKeyringPair;
- // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
- await createCollectionExpectSuccess();
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
});
});
- it('Collection admin can\'t change owner.', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const collectionId = await createCollectionExpectSuccess();
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
-
- await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
-
- const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
- await expect(submitTransactionExpectFailAsync(bob, changeOwnerTx)).to.be.rejected;
-
- const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
- expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(alice.address);
-
- // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
- await createCollectionExpectSuccess();
- });
+ itSub('Not owner can\'t change owner.', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+ await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
});
- it('Can\'t change owner of a non-existing collection.', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const collectionId = (1<<32) - 1;
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
-
- const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
- await expect(submitTransactionExpectFailAsync(alice, changeOwnerTx)).to.be.rejected;
+ itSub('Collection admin can\'t change owner.', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.addAdmin(alice, {Substrate: bob.address});
+ const changeOwnerTx = async () => collection.changeOwner(bob, bob.address);
+ await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
+ });
- // Verifying that nothing bad happened (network is live, new collections can be created, etc.)
- await createCollectionExpectSuccess();
- });
+ itSub('Can\'t change owner of a non-existing collection.', async ({helper}) => {
+ const collectionId = (1 << 32) - 1;
+ const changeOwnerTx = async () => helper.collection.changeOwner(bob, collectionId, bob.address);
+ await expect(changeOwnerTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
});
- it('Former collectionOwner not allowed to sponsorship management operations in the collection', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const collectionId = await createCollectionExpectSuccess();
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
+ itSub('Former collectionOwner not allowed to sponsorship management operations in the collection', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.changeOwner(alice, bob.address);
- const collection = await queryCollectionExpectSuccess(api, collectionId);
- expect(collection.owner.toString()).to.be.deep.eq(alice.address);
+ const changeOwnerTx = async () => collection.changeOwner(alice, alice.address);
+ await expect(changeOwnerTx()).to.be.rejectedWith(/common\.NoPermission/);
- const changeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, bob.address);
- await submitTransactionAsync(alice, changeOwnerTx);
+ const afterChanging = await helper.collection.getData(collection.collectionId);
+ expect(afterChanging?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(bob.address));
- const badChangeOwnerTx = api.tx.unique.changeCollectionOwner(collectionId, alice.address);
- await expect(submitTransactionExpectFailAsync(alice, badChangeOwnerTx)).to.be.rejected;
+ const setSponsorTx = async () => collection.setSponsor(alice, charlie.address);
+ const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
+ const removeSponsorTx = async () => collection.removeSponsor(alice);
+ await expect(setSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
+ await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
+ await expect(removeSponsorTx()).to.be.rejectedWith(/common\.NoPermission/);
- const collectionAfterOwnerChange = await queryCollectionExpectSuccess(api, collectionId);
- expect(collectionAfterOwnerChange.owner.toString()).to.be.deep.eq(bob.address);
+ const limits = {
+ accountTokenOwnershipLimit: 1,
+ tokenLimit: 1,
+ sponsorTransferTimeout: 1,
+ ownerCanDestroy: true,
+ ownerCanTransfer: true,
+ };
- await setCollectionSponsorExpectFailure(collectionId, charlie.address, '//Alice');
- await confirmSponsorshipExpectFailure(collectionId, '//Alice');
- await removeCollectionSponsorExpectFailure(collectionId, '//Alice');
+ const setLimitsTx = async () => collection.setLimits(alice, limits);
+ await expect(setLimitsTx()).to.be.rejectedWith(/common\.NoPermission/);
- const collectionLimits = {
- accountTokenOwnershipLimit: 1,
- sponsoredMintSize: 1,
- tokenLimit: 1,
- sponsorTransferTimeout: 1,
- ownerCanTransfer: true,
- ownerCanDestroy: true,
- };
- const tx1 = api.tx.unique.setCollectionLimits(
- collectionId,
- collectionLimits,
- );
- await expect(submitTransactionExpectFailAsync(alice, tx1)).to.be.rejected;
+ const setPermissionTx = async () => collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+ await expect(setPermissionTx()).to.be.rejectedWith(/common\.NoPermission/);
- await enableAllowListExpectFail(alice, collectionId);
- await setMintPermissionExpectFailure(alice, collectionId, true);
- await destroyCollectionExpectFailure(collectionId, '//Alice');
- });
+ const burnTx = async () => collection.burn(alice);
+ await expect(burnTx()).to.be.rejectedWith(/common\.NoPermission/);
});
});
tests/src/confirmSponsorship.test.tsdiffbeforeafterboth--- a/tests/src/confirmSponsorship.test.ts
+++ b/tests/src/confirmSponsorship.test.ts
@@ -14,404 +14,230 @@
// You should have received a copy of the GNU General Public License
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
-import {
- createCollectionExpectSuccess,
- setCollectionSponsorExpectSuccess,
- destroyCollectionExpectSuccess,
- confirmSponsorshipExpectSuccess,
- confirmSponsorshipExpectFailure,
- createItemExpectSuccess,
- findUnusedAddress,
- getGenericResult,
- enableAllowListExpectSuccess,
- enablePublicMintingExpectSuccess,
- addToAllowListExpectSuccess,
- normalizeAccountId,
- addCollectionAdminExpectSuccess,
- getCreatedCollectionCount,
- UNIQUE,
- requirePallets,
- Pallets,
-} from './util/helpers';
import {IKeyringPair} from '@polkadot/types/types';
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+async function setSponsorHelper(collection: any, signer: IKeyringPair, sponsorAddress: string) {
+ await collection.setSponsor(signer, sponsorAddress);
+ const raw = (await collection.getData())?.raw;
+ expect(raw.sponsorship.Unconfirmed).to.be.equal(sponsorAddress);
+}
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-let charlie: IKeyringPair;
+async function confirmSponsorHelper(collection: any, signer: IKeyringPair) {
+ await collection.confirmSponsorship(signer);
+ const raw = (await collection.getData())?.raw;
+ expect(raw.sponsorship.Confirmed).to.be.equal(signer.address);
+}
describe('integration test: ext. confirmSponsorship():', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+ let charlie: IKeyringPair;
+ let zeroBalance: IKeyringPair;
before(async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- alice = privateKeyWrapper('//Alice');
- bob = privateKeyWrapper('//Bob');
- charlie = privateKeyWrapper('//Charlie');
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob, charlie, zeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n], donor);
});
});
- it('Confirm collection sponsorship', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
+ itSub('Confirm collection sponsorship', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await setSponsorHelper(collection, alice, bob.address);
+ await confirmSponsorHelper(collection, bob);
});
- it('Add sponsor to a collection after the same sponsor was already added and confirmed', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
+
+ itSub('Add sponsor to a collection after the same sponsor was already added and confirmed', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await setSponsorHelper(collection, alice, bob.address);
+ await confirmSponsorHelper(collection, bob);
+ await setSponsorHelper(collection, alice, bob.address);
});
- it('Add new sponsor to a collection after another sponsor was already added and confirmed', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
- await setCollectionSponsorExpectSuccess(collectionId, charlie.address);
+ itSub('Add new sponsor to a collection after another sponsor was already added and confirmed', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await setSponsorHelper(collection, alice, bob.address);
+ await confirmSponsorHelper(collection, bob);
+ await setSponsorHelper(collection, alice, charlie.address);
});
- it('NFT: Transfer fees are paid by the sponsor after confirmation', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
- await usingApi(async (api, privateKeyWrapper) => {
- const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- // Find unused address
- const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Mint token for unused address
- const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', zeroBalance.address);
-
- // Transfer this tokens from unused address to Alice
- const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 0);
- const events = await submitTransactionAsync(zeroBalance, zeroToAlice);
- const result = getGenericResult(events);
- expect(result.success).to.be.true;
-
- const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
- });
-
+ itSub('NFT: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ await collection.confirmSponsorship(bob);
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+ const token = await collection.mintToken(alice, {Substrate: zeroBalance.address});
+ await token.transfer(zeroBalance, {Substrate: alice.address});
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+ expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
});
- it('Fungible: Transfer fees are paid by the sponsor after confirmation', async () => {
- const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
- await usingApi(async (api, privateKeyWrapper) => {
- const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- // Find unused address
- const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Mint token for unused address
- const itemId = await createItemExpectSuccess(alice, collectionId, 'Fungible', zeroBalance.address);
-
- // Transfer this tokens from unused address to Alice
- const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 1);
- const events1 = await submitTransactionAsync(zeroBalance, zeroToAlice);
- const result1 = getGenericResult(events1);
- expect(result1.success).to.be.true;
-
- const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
- });
+ itSub('Fungible: Transfer fees are paid by the sponsor after confirmation', async ({helper}) => {
+ const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+ await collection.setSponsor(alice, bob.address);
+ await collection.confirmSponsorship(bob);
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+ await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
+ await collection.transfer(zeroBalance, {Substrate: alice.address}, 1n);
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+ expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
});
-
- it('ReFungible: Transfer fees are paid by the sponsor after confirmation', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
-
- const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
- await usingApi(async (api, privateKeyWrapper) => {
- const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
- // Find unused address
- const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Mint token for unused address
- const itemId = await createItemExpectSuccess(alice, collectionId, 'ReFungible', zeroBalance.address);
-
- // Transfer this tokens from unused address to Alice
- const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 1);
- const events1 = await submitTransactionAsync(zeroBalance, zeroToAlice);
- const result1 = getGenericResult(events1);
-
- const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- expect(result1.success).to.be.true;
- expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
- });
+ itSub.ifWithPallets('ReFungible: Transfer fees are paid by the sponsor after confirmation', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ await collection.confirmSponsorship(bob);
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+ const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
+ await token.transfer(zeroBalance, {Substrate: alice.address}, 1n);
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
+ expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
});
-
- it('CreateItem fees are paid by the sponsor after confirmation', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
- // Enable collection allow list
- await enableAllowListExpectSuccess(alice, collectionId);
- // Enable public minting
- await enablePublicMintingExpectSuccess(alice, collectionId);
-
- // Create Item
- await usingApi(async (api, privateKeyWrapper) => {
- const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- // Find unused address
- const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Add zeroBalance address to allow list
- await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);
-
- // Mint token using unused address as signer
- await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);
+ itSub('CreateItem fees are paid by the sponsor after confirmation', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ await collection.confirmSponsorship(bob);
+ await collection.setPermissions(alice, {access: 'AllowList', mintMode: true});
+ await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
- const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+ await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
- expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
- });
+ expect(bobBalanceAfter < bobBalanceBefore).to.be.true;
});
- it('NFT: Sponsoring of transfers is rate limited', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
+ itSub('NFT: Sponsoring of transfers is rate limited', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ await collection.confirmSponsorship(bob);
- await usingApi(async (api, privateKeyWrapper) => {
- // Find unused address
- const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Mint token for alice
- const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', alice.address);
+ const token = await collection.mintToken(alice, {Substrate: alice.address});
+ await token.transfer(alice, {Substrate: zeroBalance.address});
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
- // Transfer this token from Alice to unused address and back
- // Alice to Zero gets sponsored
- const aliceToZero = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 0);
- const events1 = await submitTransactionAsync(alice, aliceToZero);
- const result1 = getGenericResult(events1);
+ const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+ await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
- // Second transfer should fail
- const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
- const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(alice.address), collectionId, itemId, 0);
- const badTransaction = async function () {
- await submitTransactionExpectFailAsync(zeroBalance, zeroToAlice);
- };
- await expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees');
- const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- // Try again after Zero gets some balance - now it should succeed
- const balancetx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);
- await submitTransactionAsync(alice, balancetx);
- const events2 = await submitTransactionAsync(zeroBalance, zeroToAlice);
- const result2 = getGenericResult(events2);
-
- expect(result1.success).to.be.true;
- expect(result2.success).to.be.true;
- expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
- });
+ expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
});
- it('Fungible: Sponsoring is rate limited', async () => {
- const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
- await usingApi(async (api, privateKeyWrapper) => {
- // Find unused address
- const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Mint token for unused address
- const itemId = await createItemExpectSuccess(alice, collectionId, 'Fungible', zeroBalance.address);
-
- // Transfer this tokens in parts from unused address to Alice
- const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(zeroBalance.address), collectionId, itemId, 1);
- const events1 = await submitTransactionAsync(zeroBalance, zeroToAlice);
- const result1 = getGenericResult(events1);
- expect(result1.success).to.be.true;
+ itSub('Fungible: Sponsoring is rate limited', async ({helper}) => {
+ const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ await collection.confirmSponsorship(bob);
- const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
- await expect(submitTransactionExpectFailAsync(zeroBalance, zeroToAlice)).to.be.rejected;
- const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
+ await collection.mint(alice, 100n, {Substrate: zeroBalance.address});
+ await collection.transfer(zeroBalance, {Substrate: zeroBalance.address}, 1n);
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
- // Try again after Zero gets some balance - now it should succeed
- const balancetx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);
- await submitTransactionAsync(alice, balancetx);
- const events2 = await submitTransactionAsync(zeroBalance, zeroToAlice);
- const result2 = getGenericResult(events2);
- expect(result2.success).to.be.true;
+ const transferTx = async () => collection.transfer(zeroBalance, {Substrate: zeroBalance.address});
+ await expect(transferTx()).to.be.rejected;
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
- expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
- });
+ expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
});
-
- it('ReFungible: Sponsoring is rate limited', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
- const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
- await usingApi(async (api, privateKeyWrapper) => {
- // Find unused address
- const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Mint token for alice
- const itemId = await createItemExpectSuccess(alice, collectionId, 'ReFungible', zeroBalance.address);
+ itSub.ifWithPallets('ReFungible: Sponsoring is rate limited', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ await collection.confirmSponsorship(bob);
- const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(alice.address), collectionId, itemId, 1);
-
- // Zero to alice gets sponsored
- const events1 = await submitTransactionAsync(zeroBalance, zeroToAlice);
- const result1 = getGenericResult(events1);
- expect(result1.success).to.be.true;
+ const token = await collection.mintToken(alice, 100n, {Substrate: zeroBalance.address});
+ await token.transfer(zeroBalance, {Substrate: alice.address});
- // Second transfer should fail
- const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
- await expect(submitTransactionExpectFailAsync(zeroBalance, zeroToAlice)).to.be.rejectedWith('Inability to pay some fees');
- const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
- expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+ const transferTx = async () => token.transfer(zeroBalance, {Substrate: alice.address});
+ await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
- // Try again after Zero gets some balance - now it should succeed
- const balancetx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);
- await submitTransactionAsync(alice, balancetx);
- const events2 = await submitTransactionAsync(zeroBalance, zeroToAlice);
- const result2 = getGenericResult(events2);
- expect(result2.success).to.be.true;
- });
+ expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
});
- it('NFT: Sponsoring of createItem is rate limited', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
- // Enable collection allow list
- await enableAllowListExpectSuccess(alice, collectionId);
-
- // Enable public minting
- await enablePublicMintingExpectSuccess(alice, collectionId);
-
- await usingApi(async (api, privateKeyWrapper) => {
- // Find unused address
- const zeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Add zeroBalance address to allow list
- await addToAllowListExpectSuccess(alice, collectionId, zeroBalance.address);
+ itSub('NFT: Sponsoring of createItem is rate limited', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ await collection.confirmSponsorship(bob);
+ await collection.setPermissions(alice, {mintMode: true, access: 'AllowList'});
+ await collection.addToAllowList(alice, {Substrate: zeroBalance.address});
- // Mint token using unused address as signer - gets sponsored
- await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);
+ await collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
- // Second mint should fail
- const sponsorBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
+ const mintTx = async () => collection.mintToken(zeroBalance, {Substrate: zeroBalance.address});
+ await expect(mintTx()).to.be.rejectedWith('Inability to pay some fees');
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
- const badTransaction = async function () {
- await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);
- };
- await expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees');
- const sponsorBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- // Try again after Zero gets some balance - now it should succeed
- const balancetx = api.tx.balances.transfer(zeroBalance.address, 1n * UNIQUE);
- await submitTransactionAsync(alice, balancetx);
- await createItemExpectSuccess(zeroBalance, collectionId, 'NFT', zeroBalance.address);
-
- expect(sponsorBalanceAfter).to.be.equal(sponsorBalanceBefore);
- });
+ expect(bobBalanceAfter === bobBalanceBefore).to.be.true;
});
-
});
describe('(!negative test!) integration test: ext. confirmSponsorship():', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+ let charlie: IKeyringPair;
+ let ownerZeroBalance: IKeyringPair;
+ let senderZeroBalance: IKeyringPair;
+
before(async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- alice = privateKeyWrapper('//Alice');
- bob = privateKeyWrapper('//Bob');
- charlie = privateKeyWrapper('//Charlie');
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob, charlie, ownerZeroBalance, senderZeroBalance] = await helper.arrange.createAccounts([100n, 100n, 100n, 0n, 0n], donor);
});
});
- it('(!negative test!) Confirm sponsorship for a collection that never existed', async () => {
- // Find the collection that never existed
- let collectionId = 0;
- await usingApi(async (api) => {
- collectionId = await getCreatedCollectionCount(api) + 1;
- });
-
- await confirmSponsorshipExpectFailure(collectionId, '//Bob');
+ itSub('(!negative test!) Confirm sponsorship for a collection that never existed', async ({helper}) => {
+ const collectionId = 1_000_000;
+ const confirmSponsorshipTx = async () => helper.collection.confirmSponsorship(bob, collectionId);
+ await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
});
-
- it('(!negative test!) Confirm sponsorship using a non-sponsor address', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
-
- await usingApi(async (api) => {
- const transfer = api.tx.balances.transfer(charlie.address, 1e15);
- await submitTransactionAsync(alice, transfer);
- });
- await confirmSponsorshipExpectFailure(collectionId, '//Charlie');
+ itSub('(!negative test!) Confirm sponsorship using a non-sponsor address', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+ await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
});
- it('(!negative test!) Confirm sponsorship using owner address', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectFailure(collectionId, '//Alice');
+ itSub('(!negative test!) Confirm sponsorship using owner address', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ const confirmSponsorshipTx = async () => collection.confirmSponsorship(alice);
+ await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
});
- it('(!negative test!) Confirm sponsorship by collection admin', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await addCollectionAdminExpectSuccess(alice, collectionId, charlie.address);
- await confirmSponsorshipExpectFailure(collectionId, '//Charlie');
+ itSub('(!negative test!) Confirm sponsorship by collection admin', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ await collection.addAdmin(alice, {Substrate: charlie.address});
+ const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+ await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
});
- it('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await confirmSponsorshipExpectFailure(collectionId, '//Bob');
+ itSub('(!negative test!) Confirm sponsorship without sponsor being set with setCollectionSponsor', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+ await expect(confirmSponsorshipTx()).to.be.rejectedWith(/unique\.ConfirmUnsetSponsorFail/);
});
- it('(!negative test!) Confirm sponsorship in a collection that was destroyed', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await destroyCollectionExpectSuccess(collectionId);
- await confirmSponsorshipExpectFailure(collectionId, '//Bob');
+ itSub('(!negative test!) Confirm sponsorship in a collection that was destroyed', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.burn(alice);
+ const confirmSponsorshipTx = async () => collection.confirmSponsorship(charlie);
+ await expect(confirmSponsorshipTx()).to.be.rejectedWith(/common\.CollectionNotFound/);
});
- it('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionSponsorExpectSuccess(collectionId, bob.address);
- await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
-
- await usingApi(async (api, privateKeyWrapper) => {
- // Find unused address
- const ownerZeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Find another unused address
- const senderZeroBalance = await findUnusedAddress(api, privateKeyWrapper);
-
- // Mint token for an unused address
- const itemId = await createItemExpectSuccess(alice, collectionId, 'NFT', ownerZeroBalance.address);
-
- const sponsorBalanceBeforeTx = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- // Try to transfer this token from an unsponsored unused adress to Alice
- const zeroToAlice = api.tx.unique.transfer(normalizeAccountId(alice.address), collectionId, itemId, 0);
- await expect(submitTransactionExpectFailAsync(senderZeroBalance, zeroToAlice)).to.be.rejected;
-
- const sponsorBalanceAfterTx = (await api.query.system.account(bob.address)).data.free.toBigInt();
-
- expect(sponsorBalanceAfterTx).to.equal(sponsorBalanceBeforeTx);
- });
+ itSub('(!negative test!) Transfer fees are not paid by the sponsor if the transfer failed', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.setSponsor(alice, bob.address);
+ await collection.confirmSponsorship(bob);
+ const token = await collection.mintToken(alice, {Substrate: ownerZeroBalance.address});
+ const sponsorBalanceBefore = await helper.balance.getSubstrate(bob.address);
+ const transferTx = async () => token.transfer(senderZeroBalance, {Substrate: alice.address});
+ await expect(transferTx()).to.be.rejectedWith('Inability to pay some fees');
+ const sponsorBalanceAfter = await helper.balance.getSubstrate(bob.address);
+ expect(sponsorBalanceAfter).to.equal(sponsorBalanceBefore);
});
});
tests/src/createCollection.test.tsdiffbeforeafterboth--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -14,130 +14,143 @@
// You should have received a copy of the GNU General Public License
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-import {expect} from 'chai';
-import usingApi, {executeTransaction, submitTransactionAsync} from './substrate/substrate-api';
-import {createCollectionWithPropsExpectFailure, createCollectionExpectFailure, createCollectionExpectSuccess, getCreateCollectionResult, getDetailedCollectionInfo, createCollectionWithPropsExpectSuccess, requirePallets, Pallets} from './util/helpers';
+import {IKeyringPair} from '@polkadot/types/types';
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
+import {ICollectionCreationOptions, IProperty} from './util/playgrounds/types';
+import {UniqueHelper} from './util/playgrounds/unique';
+async function mintCollectionHelper(helper: UniqueHelper, signer: IKeyringPair, options: ICollectionCreationOptions, type?: 'nft' | 'fungible' | 'refungible') {
+ let collection;
+ if (type === 'nft') {
+ collection = await helper.nft.mintCollection(signer, options);
+ } else if (type === 'fungible') {
+ collection = await helper.ft.mintCollection(signer, options, 0);
+ } else {
+ collection = await helper.rft.mintCollection(signer, options);
+ }
+ const data = await collection.getData();
+ expect(data?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(signer.address));
+ expect(data?.name).to.be.equal(options.name);
+ expect(data?.description).to.be.equal(options.description);
+ expect(data?.raw.tokenPrefix).to.be.equal(options.tokenPrefix);
+ if (options.properties) {
+ expect(data?.raw.properties).to.be.deep.equal(options.properties);
+ }
+
+ if (options.tokenPropertyPermissions) {
+ expect(data?.raw.tokenPropertyPermissions).to.be.deep.equal(options.tokenPropertyPermissions);
+ }
+
+ return collection;
+}
+
describe('integration test: ext. createCollection():', () => {
- it('Create new NFT collection', async () => {
- await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
+ let alice: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice] = await helper.arrange.createAccounts([100n], donor);
+ });
});
- it('Create new NFT collection whith collection_name of maximum length (64 bytes)', async () => {
- await createCollectionExpectSuccess({name: 'A'.repeat(64)});
+ itSub('Create new NFT collection', async ({helper}) => {
+ await mintCollectionHelper(helper, alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 'nft');
});
- it('Create new NFT collection whith collection_description of maximum length (256 bytes)', async () => {
- await createCollectionExpectSuccess({description: 'A'.repeat(256)});
+ itSub('Create new NFT collection whith collection_name of maximum length (64 bytes)', async ({helper}) => {
+ await mintCollectionHelper(helper, alice, {name: 'A'.repeat(64), description: 'descr', tokenPrefix: 'COL'}, 'nft');
});
- it('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async () => {
- await createCollectionExpectSuccess({tokenPrefix: 'A'.repeat(16)});
+ itSub('Create new NFT collection whith collection_description of maximum length (256 bytes)', async ({helper}) => {
+ await mintCollectionHelper(helper, alice, {name: 'name', description: 'A'.repeat(256), tokenPrefix: 'COL'}, 'nft');
});
- it('Create new Fungible collection', async () => {
- await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+ itSub('Create new NFT collection whith token_prefix of maximum length (16 bytes)', async ({helper}) => {
+ await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(16)}, 'nft');
});
- it('Create new ReFungible collection', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
- await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
+ itSub('Create new Fungible collection', async ({helper}) => {
+ await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'fungible');
});
- it('create new collection with properties #1', async () => {
- await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'},
- properties: [{key: 'key1', value: 'val1'}],
- propPerm: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}]});
+ itSub.ifWithPallets('Create new ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+ await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'refungible');
});
- it('create new collection with properties #2', async () => {
- await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'},
+ itSub('create new collection with properties', async ({helper}) => {
+ await mintCollectionHelper(helper, alice, {
+ name: 'name', description: 'descr', tokenPrefix: 'COL',
properties: [{key: 'key1', value: 'val1'}],
- propPerm: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}]});
+ tokenPropertyPermissions: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}],
+ }, 'nft');
});
- it('create new collection with properties #3', async () => {
- await createCollectionWithPropsExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'},
- properties: [{key: 'key1', value: 'val1'}],
- propPerm: [{key: 'key1', permission: {tokenOwner: true, mutable: false, collectionAdmin: true}}]});
- });
+ itSub('Create new collection with extra fields', async ({helper}) => {
+ const collection = await mintCollectionHelper(helper, alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'}, 'fungible');
+ await collection.setPermissions(alice, {access: 'AllowList'});
+ await collection.setLimits(alice, {accountTokenOwnershipLimit: 3});
+ const data = await collection.getData();
+ const limits = await collection.getEffectiveLimits();
+ const raw = data?.raw;
- it('Create new collection with extra fields', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const tx = api.tx.unique.createCollectionEx({
- mode: {Fungible: 8},
- permissions: {
- access: 'AllowList',
- },
- name: [1],
- description: [2],
- tokenPrefix: '0x000000',
- pendingSponsor: bob.address,
- limits: {
- accountTokenOwnershipLimit: 3,
- },
- });
- const events = await submitTransactionAsync(alice, tx);
- const result = getCreateCollectionResult(events);
+ expect(data?.normalizedOwner).to.be.equal(helper.address.normalizeSubstrate(alice.address));
+ expect(data?.name).to.be.equal('name');
+ expect(data?.description).to.be.equal('descr');
+ expect(raw.permissions.access).to.be.equal('AllowList');
+ expect(raw.mode).to.be.deep.equal({Fungible: '0'});
+ expect(limits.accountTokenOwnershipLimit).to.be.equal(3);
+ });
- const collection = (await getDetailedCollectionInfo(api, result.collectionId))!;
- expect(collection.owner.toString()).to.equal(alice.address);
- expect(collection.mode.asFungible.toNumber()).to.equal(8);
- expect(collection.permissions.access.toHuman()).to.equal('AllowList');
- expect(collection.name.map(v => v.toNumber())).to.deep.equal([1]);
- expect(collection.description.map(v => v.toNumber())).to.deep.equal([2]);
- expect(collection.tokenPrefix.toString()).to.equal('0x000000');
- expect(collection.sponsorship.asUnconfirmed.toString()).to.equal(bob.address);
- expect(collection.limits.accountTokenOwnershipLimit.unwrap().toNumber()).to.equal(3);
- });
+ itSub('New collection is not external', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL'});
+ const data = await collection.getData();
+ expect(data?.raw.readOnly).to.be.false;
});
+});
- it('New collection is not external', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const tx = api.tx.unique.createCollectionEx({ });
- const events = await submitTransactionAsync(alice, tx);
- const result = getCreateCollectionResult(events);
+describe('(!negative test!) integration test: ext. createCollection():', () => {
+ let alice: IKeyringPair;
- const collection = (await getDetailedCollectionInfo(api, result.collectionId))!;
- expect(collection.readOnly.toHuman()).to.be.false;
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice] = await helper.arrange.createAccounts([100n], donor);
});
});
-});
-describe('(!negative test!) integration test: ext. createCollection():', () => {
- it('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async () => {
- await createCollectionExpectFailure({name: 'A'.repeat(65), mode: {type: 'NFT'}});
+ itSub('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async ({helper}) => {
+ const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'A'.repeat(65), description: 'descr', tokenPrefix: 'COL'});
+ await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
});
- it('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async () => {
- await createCollectionExpectFailure({description: 'A'.repeat(257), mode: {type: 'NFT'}});
+ itSub('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async ({helper}) => {
+ const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'A'.repeat(257), tokenPrefix: 'COL'});
+ await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
});
- it('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async () => {
- await createCollectionExpectFailure({tokenPrefix: 'A'.repeat(17), mode: {type: 'NFT'}});
+ itSub('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async ({helper}) => {
+ const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'A'.repeat(17)});
+ await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
});
- it('fails when bad limits are set', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const tx = api.tx.unique.createCollectionEx({mode: 'NFT', limits: {tokenLimit: 0}});
- await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/^common.CollectionTokenLimitExceeded$/);
- });
+
+ itSub('(!negative test!) fails when bad limits are set', async ({helper}) => {
+ const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', limits: {tokenLimit: 0}});
+ await expect(mintCollectionTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);
});
- it('(!negative test!) create collection with incorrect property limit (64 elements)', async () => {
- const props = [];
+ itSub('(!negative test!) create collection with incorrect property limit (64 elements)', async ({helper}) => {
+ const props: IProperty[] = [];
for (let i = 0; i < 65; i++) {
props.push({key: `key${i}`, value: `value${i}`});
}
-
- await createCollectionWithPropsExpectFailure({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}, properties: props});
+ const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+ await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
});
- it('(!negative test!) create collection with incorrect property limit (40 kb)', async () => {
- const props = [];
+ itSub('(!negative test!) create collection with incorrect property limit (40 kb)', async ({helper}) => {
+ const props: IProperty[] = [];
for (let i = 0; i < 32; i++) {
props.push({key: `key${i}`.repeat(80), value: `value${i}`.repeat(80)});
}
- await createCollectionWithPropsExpectFailure({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}, properties: props});
+ const mintCollectionTx = async () => helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL', properties: props});
+ await expect(mintCollectionTx()).to.be.rejectedWith('Verification Error');
});
});
tests/src/createItem.test.tsdiffbeforeafterboth--- a/tests/src/createItem.test.ts
+++ b/tests/src/createItem.test.ts
@@ -14,308 +14,259 @@
// You should have received a copy of the GNU General Public License
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-import {default as usingApi, executeTransaction} from './substrate/substrate-api';
-import chai from 'chai';
import {IKeyringPair} from '@polkadot/types/types';
-import {
- createCollectionExpectSuccess,
- createItemExpectSuccess,
- addCollectionAdminExpectSuccess,
- createCollectionWithPropsExpectSuccess,
- createItemWithPropsExpectSuccess,
- createItemWithPropsExpectFailure,
- createCollection,
- transferExpectSuccess,
- itApi,
- normalizeAccountId,
- getCreateItemResult,
- requirePallets,
- Pallets,
-} from './util/helpers';
+import {usingPlaygrounds, expect, itSub, Pallets} from './util/playgrounds';
+import {IProperty, ICrossAccountId} from './util/playgrounds/types';
+import {UniqueHelper} from './util/playgrounds/unique';
+
+async function mintTokenHelper(helper: UniqueHelper, collection: any, signer: IKeyringPair, owner: ICrossAccountId, type: 'nft' | 'fungible' | 'refungible'='nft', properties?: IProperty[]) {
+ let token;
+ const itemCountBefore = await helper.collection.getLastTokenId(collection.collectionId);
+ const itemBalanceBefore = (await helper.callRpc('api.rpc.unique.balance', [collection.collectionId, owner, 0])).toBigInt();
+ if (type === 'nft') {
+ token = await collection.mintToken(signer, owner, properties);
+ } else if (type === 'fungible') {
+ await collection.mint(signer, 10n, owner);
+ } else {
+ token = await collection.mintToken(signer, 100n, owner, properties);
+ }
+
+ const itemCountAfter = await helper.collection.getLastTokenId(collection.collectionId);
+ const itemBalanceAfter = (await helper.callRpc('api.rpc.unique.balance', [collection.collectionId, owner, 0])).toBigInt();
+
+ if (type === 'fungible') {
+ expect(itemBalanceAfter - itemBalanceBefore).to.be.equal(10n);
+ } else {
+ expect(itemCountAfter).to.be.equal(itemCountBefore + 1);
+ }
+
+ return token;
+}
-const expect = chai.expect;
-let alice: IKeyringPair;
-let bob: IKeyringPair;
describe('integration test: ext. ():', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
before(async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- alice = privateKeyWrapper('//Alice');
- bob = privateKeyWrapper('//Bob');
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
});
});
- it('Create new item in NFT collection', async () => {
- const createMode = 'NFT';
- const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
- await createItemExpectSuccess(alice, newCollectionID, createMode);
+ itSub('Create new item in NFT collection', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await mintTokenHelper(helper, collection, alice, {Substrate: alice.address});
});
- it('Create new item in Fungible collection', async () => {
- const createMode = 'Fungible';
- const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
- await createItemExpectSuccess(alice, newCollectionID, createMode);
+ itSub('Create new item in Fungible collection', async ({helper}) => {
+ const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+ await mintTokenHelper(helper, collection, alice, {Substrate: alice.address}, 'fungible');
});
- itApi('Check events on create new item in Fungible collection', async ({api}) => {
- const createMode = 'Fungible';
-
- const newCollectionID = (await createCollection(api, alice, {mode: {type: createMode, decimalPoints: 0}})).collectionId;
-
- const to = normalizeAccountId(alice);
+ itSub('Check events on create new item in Fungible collection', async ({helper}) => {
+ const {collectionId} = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'}, 0);
+ const to = {Substrate: alice.address};
{
const createData = {fungible: {value: 100}};
- const tx = api.tx.unique.createItem(newCollectionID, to, createData as any);
- const events = await executeTransaction(api, alice, tx);
- const result = getCreateItemResult(events);
- expect(result.amount).to.be.equal(100);
- expect(result.collectionId).to.be.equal(newCollectionID);
- expect(result.recipient).to.be.deep.equal(to);
+ const events = await helper.executeExtrinsic(alice, 'api.tx.unique.createItem', [collectionId, to, createData as any]);
+ const result = helper.util.extractTokensFromCreationResult(events);
+ expect(result.tokens[0].amount).to.be.equal(100n);
+ expect(result.tokens[0].collectionId).to.be.equal(collectionId);
+ expect(result.tokens[0].owner).to.be.deep.equal(to);
}
{
const createData = {fungible: {value: 50}};
- const tx = api.tx.unique.createItem(newCollectionID, to, createData as any);
- const events = await executeTransaction(api, alice, tx);
- const result = getCreateItemResult(events);
- expect(result.amount).to.be.equal(50);
- expect(result.collectionId).to.be.equal(newCollectionID);
- expect(result.recipient).to.be.deep.equal(to);
+ const events = await helper.executeExtrinsic(alice, 'api.tx.unique.createItem', [collectionId, to, createData as any]);
+ const result = helper.util.extractTokensFromCreationResult(events);
+ expect(result.tokens[0].amount).to.be.equal(50n);
+ expect(result.tokens[0].collectionId).to.be.equal(collectionId);
+ expect(result.tokens[0].owner).to.be.deep.equal(to);
}
-
});
- it('Create new item in ReFungible collection', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
-
- const createMode = 'ReFungible';
- const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
- await createItemExpectSuccess(alice, newCollectionID, createMode);
+ itSub.ifWithPallets('Create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await mintTokenHelper(helper, collection, alice, {Substrate: alice.address}, 'refungible');
});
- it('Create new item in NFT collection with collection admin permissions', async () => {
- const createMode = 'NFT';
- const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
- await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
- await createItemExpectSuccess(bob, newCollectionID, createMode);
+ itSub('Create new item in NFT collection with collection admin permissions', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.addAdmin(alice, {Substrate: bob.address});
+ await mintTokenHelper(helper, collection, bob, {Substrate: alice.address});
});
- it('Create new item in Fungible collection with collection admin permissions', async () => {
- const createMode = 'Fungible';
- const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
- await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
- await createItemExpectSuccess(bob, newCollectionID, createMode);
+ itSub('Create new item in Fungible collection with collection admin permissions', async ({helper}) => {
+ const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+ await collection.addAdmin(alice, {Substrate: bob.address});
+ await mintTokenHelper(helper, collection, bob, {Substrate: alice.address}, 'fungible');
});
- it('Create new item in ReFungible collection with collection admin permissions', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
-
- const createMode = 'ReFungible';
- const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
- await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
- await createItemExpectSuccess(bob, newCollectionID, createMode);
+ itSub.ifWithPallets('Create new item in ReFungible collection with collection admin permissions', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ await collection.addAdmin(alice, {Substrate: bob.address});
+ await mintTokenHelper(helper, collection, bob, {Substrate: alice.address}, 'refungible');
});
- it('Set property Admin', async () => {
- const createMode = 'NFT';
- const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode},
- propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: false}}]});
-
- await createItemWithPropsExpectSuccess(alice, newCollectionID, createMode, [{key: 'k', value: 't2'}]);
+ itSub('Set property Admin', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+ properties: [{key: 'k', value: 'v'}],
+ tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}}],
+ });
+ await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'nft', [{key: 'k', value: 'v'}]);
});
- it('Set property AdminConst', async () => {
- const createMode = 'NFT';
- const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode},
- propPerm: [{key: 'key1', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}}]});
-
- await createItemWithPropsExpectSuccess(alice, newCollectionID, createMode, [{key: 'key1', value: 'val1'}]);
- });
-
- it('Set property itemOwnerOrAdmin', async () => {
- const createMode = 'NFT';
- const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode},
- propPerm: [{key: 'key1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]});
-
- await createItemWithPropsExpectSuccess(alice, newCollectionID, createMode, [{key: 'key1', value: 'val1'}]);
- });
-
- it('Check total pieces of Fungible token', async () => {
- await usingApi(async api => {
- const createMode = 'Fungible';
- const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
- const amountPieces = 10n;
- const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
- {
- const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
- expect(totalPieces.isSome).to.be.true;
- expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
- }
-
- await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);
- {
- const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
- expect(totalPieces.isSome).to.be.true;
- expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
- }
-
- const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
- expect(totalPieces.toBigInt()).to.be.eq(amountPieces);
+ itSub('Set property AdminConst', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+ properties: [{key: 'k', value: 'v'}],
+ tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}}],
});
+ await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'nft', [{key: 'k', value: 'v'}]);
});
- it('Check total pieces of NFT token', async () => {
- await usingApi(async api => {
- const createMode = 'NFT';
- const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
- const amountPieces = 1n;
- const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
- {
- const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
- expect(totalPieces.isSome).to.be.true;
- expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
- }
-
- await transferExpectSuccess(collectionId, tokenId, bob, alice, 1, createMode);
- {
- const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
- expect(totalPieces.isSome).to.be.true;
- expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
- }
-
- const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
- expect(totalPieces.toBigInt()).to.be.eq(amountPieces);
+ itSub('Set property itemOwnerOrAdmin', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'descr', tokenPrefix: 'COL',
+ properties: [{key: 'k', value: 'v'}],
+ tokenPropertyPermissions: [{key: 'k', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}}],
});
+ await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'nft', [{key: 'k', value: 'v'}]);
});
- it('Check total pieces of ReFungible token', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
+ itSub('Check total pieces of Fungible token', async ({helper}) => {
+ const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+ const amount = 10n;
+ await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'fungible');
+ {
+ const totalPieces = await collection.getTotalPieces();
+ expect(totalPieces).to.be.equal(amount);
+ }
+ await collection.transfer(bob, {Substrate: alice.address}, 1n);
+ {
+ const totalPieces = await collection.getTotalPieces();
+ expect(totalPieces).to.be.equal(amount);
+ }
+ });
- await usingApi(async api => {
- const createMode = 'ReFungible';
- const createCollectionResult = await createCollection(api, alice, {mode: {type: createMode}});
- const collectionId = createCollectionResult.collectionId;
- const amountPieces = 100n;
- const tokenId = await createItemExpectSuccess(alice, collectionId, createMode, bob.address);
- {
- const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
- expect(totalPieces.isSome).to.be.true;
- expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
- }
+ itSub('Check total pieces of NFT token', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const amount = 1n;
+ const token = await mintTokenHelper(helper, collection, alice, {Substrate: bob.address});
+ {
+ const totalPieces = await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, token.tokenId]);
+ expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
+ }
+ await token.transfer(bob, {Substrate: alice.address});
+ {
+ const totalPieces = await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, token.tokenId]);
+ expect(totalPieces?.unwrap().toBigInt()).to.be.equal(amount);
+ }
+ });
- await transferExpectSuccess(collectionId, tokenId, bob, alice, 60n, createMode);
- {
- const totalPieces = await api.rpc.unique.totalPieces(collectionId, tokenId);
- expect(totalPieces.isSome).to.be.true;
- expect(totalPieces.unwrap().toBigInt()).to.be.eq(amountPieces);
- }
-
- const totalPieces = (await api.rpc.unique.tokenData(collectionId, tokenId, [])).pieces;
- expect(totalPieces.toBigInt()).to.be.eq(amountPieces);
- });
+ itSub.ifWithPallets('Check total pieces of ReFungible token', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const amount = 100n;
+ const token = await mintTokenHelper(helper, collection, alice, {Substrate: bob.address}, 'refungible');
+ {
+ const totalPieces = await token.getTotalPieces();
+ expect(totalPieces).to.be.equal(amount);
+ }
+ await token.transfer(bob, {Substrate: alice.address}, 60n);
+ {
+ const totalPieces = await token.getTotalPieces();
+ expect(totalPieces).to.be.equal(amount);
+ }
});
});
describe('Negative integration test: ext. createItem():', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
before(async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- alice = privateKeyWrapper('//Alice');
- bob = privateKeyWrapper('//Bob');
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
});
});
- it('Regular user cannot create new item in NFT collection', async () => {
- const createMode = 'NFT';
- const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
- await expect(createItemExpectSuccess(bob, newCollectionID, createMode)).to.be.rejected;
+ itSub('Regular user cannot create new item in NFT collection', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const mintTx = async () => collection.mintToken(bob, {Substrate: bob.address});
+ await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
});
- it('Regular user cannot create new item in Fungible collection', async () => {
- const createMode = 'Fungible';
- const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
- await expect(createItemExpectSuccess(bob, newCollectionID, createMode)).to.be.rejected;
+ itSub('Regular user cannot create new item in Fungible collection', async ({helper}) => {
+ const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+ const mintTx = async () => collection.mint(bob, 10n, {Substrate: bob.address});
+ await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
});
- it('Regular user cannot create new item in ReFungible collection', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
-
- const createMode = 'ReFungible';
- const newCollectionID = await createCollectionExpectSuccess({mode: {type: createMode}});
- await expect(createItemExpectSuccess(bob, newCollectionID, createMode)).to.be.rejected;
+ itSub.ifWithPallets('Regular user cannot create new item in ReFungible collection', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const mintTx = async () => collection.mintToken(bob, 100n, {Substrate: bob.address});
+ await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);
});
- it('No editing rights', async () => {
- await usingApi(async () => {
- const createMode = 'NFT';
- const newCollectionID = await createCollectionWithPropsExpectSuccess({mode: {type: createMode},
- propPerm: [{key: 'key1', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}]});
- await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
-
- await createItemWithPropsExpectFailure(bob, newCollectionID, 'NFT', [{key: 'key1', value: 'v'}]);
+ itSub('No editing rights', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+ tokenPropertyPermissions: [{key: 'k', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}],
});
+ const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+ await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
});
- it('User doesnt have editing rights', async () => {
- await usingApi(async () => {
- const newCollectionID = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}]});
- await createItemWithPropsExpectFailure(bob, newCollectionID, 'NFT', [{key: 'key1', value: 'v'}]);
+ itSub('User doesnt have editing rights', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+ tokenPropertyPermissions: [{key: 'k', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],
});
+ const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+ await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
});
- it('Adding property without access rights', async () => {
- await usingApi(async () => {
- const newCollectionID = await createCollectionWithPropsExpectSuccess();
- await addCollectionAdminExpectSuccess(alice, newCollectionID, bob.address);
-
- await createItemWithPropsExpectFailure(bob, newCollectionID, 'NFT', [{key: 'k', value: 'v'}]);
- });
+ itSub('Adding property without access rights', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [{key: 'k', value: 'v'}]);
+ await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);
});
- it('Adding more than 64 prps', async () => {
- await usingApi(async () => {
- const prps = [];
+ itSub('Adding more than 64 prps', async ({helper}) => {
+ const props: IProperty[] = [];
- for (let i = 0; i < 65; i++) {
- prps.push({key: `key${i}`, value: `value${i}`});
- }
+ for (let i = 0; i < 65; i++) {
+ props.push({key: `key${i}`, value: `value${i}`});
+ }
- const newCollectionID = await createCollectionWithPropsExpectSuccess();
-
- await createItemWithPropsExpectFailure(alice, newCollectionID, 'NFT', prps);
- });
- });
- it('Trying to add bigger property than allowed', async () => {
- await usingApi(async () => {
- const newCollectionID = await createCollectionWithPropsExpectSuccess();
-
- await createItemWithPropsExpectFailure(alice, newCollectionID, 'NFT', [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]);
- });
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, props);
+ await expect(mintTx()).to.be.rejectedWith('Verification Error');
});
- it('Check total pieces for invalid Fungible token', async () => {
- await usingApi(async api => {
- const createCollectionResult = await createCollection(api, alice, {mode: {type: 'Fungible', decimalPoints: 0}});
- const collectionId = createCollectionResult.collectionId;
- const invalidTokenId = 1000_000;
-
- expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
- expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.toBigInt()).to.be.eq(0n);
+ itSub('Trying to add bigger property than allowed', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
+ {key: 'k1', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
+ {key: 'k2', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}},
+ ],
});
+ const mintTx = async () => collection.mintToken(alice, {Substrate: bob.address}, [
+ {key: 'k1', value: 'vvvvvv'.repeat(5000)},
+ {key: 'k2', value: 'vvv'.repeat(5000)},
+ ]);
+ await expect(mintTx()).to.be.rejectedWith(/common\.NoSpaceForProperty/);
});
- it('Check total pieces for invalid NFT token', async () => {
- await usingApi(async api => {
- const createCollectionResult = await createCollection(api, alice, {mode: {type: 'NFT'}});
- const collectionId = createCollectionResult.collectionId;
- const invalidTokenId = 1000_000;
-
- expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
- expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.toBigInt()).to.be.eq(0n);
- });
+ itSub('Check total pieces for invalid Fungible token', async ({helper}) => {
+ const collection = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0);
+ const invalidTokenId = 1_000_000;
+ expect((await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, invalidTokenId]))?.isNone).to.be.true;
+ expect((await helper.callRpc('api.rpc.unique.tokenData', [collection.collectionId, invalidTokenId]))?.pieces.toBigInt()).to.be.equal(0n);
});
- it('Check total pieces for invalid Refungible token', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
+ itSub('Check total pieces for invalid NFT token', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const invalidTokenId = 1_000_000;
+ expect((await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, invalidTokenId]))?.isNone).to.be.true;
+ expect((await helper.callRpc('api.rpc.unique.tokenData', [collection.collectionId, invalidTokenId]))?.pieces.toBigInt()).to.be.equal(0n);
+ });
- await usingApi(async api => {
- const createCollectionResult = await createCollection(api, alice, {mode: {type: 'ReFungible'}});
- const collectionId = createCollectionResult.collectionId;
- const invalidTokenId = 1000_000;
-
- expect((await api.rpc.unique.totalPieces(collectionId, invalidTokenId)).isNone).to.be.true;
- expect((await api.rpc.unique.tokenData(collectionId, invalidTokenId, [])).pieces.toBigInt()).to.be.eq(0n);
- });
+ itSub.ifWithPallets('Check total pieces for invalid Refungible token', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'});
+ const invalidTokenId = 1_000_000;
+ expect((await helper.callRpc('api.rpc.unique.totalPieces', [collection.collectionId, invalidTokenId]))?.isNone).to.be.true;
+ expect((await helper.callRpc('api.rpc.unique.tokenData', [collection.collectionId, invalidTokenId]))?.pieces.toBigInt()).to.be.equal(0n);
});
});
tests/src/createMultipleItems.test.tsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {ApiPromise} from '@polkadot/api';18import {IKeyringPair} from '@polkadot/types/types';19import chai from 'chai';20import chaiAsPromised from 'chai-as-promised';21import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync, executeTransaction} from './substrate/substrate-api';22import {23 createCollectionExpectSuccess,24 destroyCollectionExpectSuccess,25 getGenericResult,26 normalizeAccountId,27 setCollectionLimitsExpectSuccess,28 addCollectionAdminExpectSuccess,29 getBalance,30 getTokenOwner,31 getLastTokenId,32 getCreatedCollectionCount,33 createCollectionWithPropsExpectSuccess,34 createMultipleItemsWithPropsExpectSuccess,35 getTokenProperties,36 requirePallets,37 Pallets,38 checkPalletsPresence,39} from './util/helpers';4041chai.use(chaiAsPromised);42const expect = chai.expect;4344describe('Integration Test createMultipleItems(collection_id, owner, items_data):', () => {45 it('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async () => {46 await usingApi(async (api, privateKeyWrapper) => {47 const collectionId = await createCollectionExpectSuccess();48 const itemsListIndexBefore = await getLastTokenId(api, collectionId);49 expect(itemsListIndexBefore).to.be.equal(0);5051 const alice = privateKeyWrapper('//Alice');52 await submitTransactionAsync(53 alice, 54 api.tx.unique.setTokenPropertyPermissions(collectionId, [{key: 'data', permission: {tokenOwner: true}}]),55 );56 57 const args = [58 {NFT: {properties: [{key: 'data', value: '1'}]}},59 {NFT: {properties: [{key: 'data', value: '2'}]}},60 {NFT: {properties: [{key: 'data', value: '3'}]}},61 ];62 const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);63 await submitTransactionAsync(alice, createMultipleItemsTx);64 const itemsListIndexAfter = await getLastTokenId(api, collectionId);65 expect(itemsListIndexAfter).to.be.equal(3);6667 expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address));68 expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address));69 expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address));7071 expect((await getTokenProperties(api, collectionId, 1, ['data']))[0].value).to.be.equal('1');72 expect((await getTokenProperties(api, collectionId, 2, ['data']))[0].value).to.be.equal('2');73 expect((await getTokenProperties(api, collectionId, 3, ['data']))[0].value).to.be.equal('3');74 });75 });7677 it('Create 0x01, 0x02, 0x03 items in active Fungible collection and verify tokens data in chain', async () => {78 await usingApi(async (api, privateKeyWrapper) => {79 const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});80 const itemsListIndexBefore = await getLastTokenId(api, collectionId);81 expect(itemsListIndexBefore).to.be.equal(0);82 const alice = privateKeyWrapper('//Alice');83 const args = [84 {Fungible: {value: 1}},85 {Fungible: {value: 2}},86 {Fungible: {value: 3}},87 ];88 const createMultipleItemsTx = api.tx.unique89 .createMultipleItems(collectionId, normalizeAccountId(alice.address), args);90 await submitTransactionAsync(alice, createMultipleItemsTx);91 const token1Data = await getBalance(api, collectionId, alice.address, 0);9293 expect(token1Data).to.be.equal(6n); // 1 + 2 + 394 });95 });9697 it('Create 0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', async function() {98 await requirePallets(this, [Pallets.ReFungible]);99100 await usingApi(async (api, privateKeyWrapper) => {101 const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});102 const itemsListIndexBefore = await getLastTokenId(api, collectionId);103 expect(itemsListIndexBefore).to.be.equal(0);104 const alice = privateKeyWrapper('//Alice');105 const args = [106 {ReFungible: {pieces: 1}},107 {ReFungible: {pieces: 2}},108 {ReFungible: {pieces: 3}},109 ];110 const createMultipleItemsTx = api.tx.unique111 .createMultipleItems(collectionId, normalizeAccountId(alice.address), args);112 await submitTransactionAsync(alice, createMultipleItemsTx);113 const itemsListIndexAfter = await getLastTokenId(api, collectionId);114 expect(itemsListIndexAfter).to.be.equal(3);115116 expect(await getBalance(api, collectionId, alice.address, 1)).to.be.equal(1n);117 expect(await getBalance(api, collectionId, alice.address, 2)).to.be.equal(2n);118 expect(await getBalance(api, collectionId, alice.address, 3)).to.be.equal(3n);119 });120 });121122 it('Can mint amount of items equals to collection limits', async () => {123 await usingApi(async (api, privateKeyWrapper) => {124 const alice = privateKeyWrapper('//Alice');125126 const collectionId = await createCollectionExpectSuccess();127 await setCollectionLimitsExpectSuccess(alice, collectionId, {128 tokenLimit: 2,129 });130 const args = [131 {NFT: {}},132 {NFT: {}},133 ];134 const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);135 const events = await submitTransactionAsync(alice, createMultipleItemsTx);136 const result = getGenericResult(events);137 expect(result.success).to.be.true;138 });139 });140141 it('Create 0x31, 0x32, 0x33 items in active NFT with property Admin', async () => {142 await usingApi(async (api, privateKeyWrapper) => {143 const collectionId = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: false}}]});144 const itemsListIndexBefore = await getLastTokenId(api, collectionId);145 expect(itemsListIndexBefore).to.be.equal(0);146 const alice = privateKeyWrapper('//Alice');147 const args = [148 {NFT: {properties: [{key: 'k', value: 'v1'}]}},149 {NFT: {properties: [{key: 'k', value: 'v2'}]}},150 {NFT: {properties: [{key: 'k', value: 'v3'}]}},151 ];152153 await createMultipleItemsWithPropsExpectSuccess(alice, collectionId, args);154 const itemsListIndexAfter = await getLastTokenId(api, collectionId);155 expect(itemsListIndexAfter).to.be.equal(3);156157 expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address));158 expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address));159 expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address));160161 expect((await getTokenProperties(api, collectionId, 1, ['k']))[0].value).to.be.equal('v1');162 expect((await getTokenProperties(api, collectionId, 2, ['k']))[0].value).to.be.equal('v2');163 expect((await getTokenProperties(api, collectionId, 3, ['k']))[0].value).to.be.equal('v3');164 });165 });166167 it('Create 0x31, 0x32, 0x33 items in active NFT with property AdminConst', async () => {168 await usingApi(async (api, privateKeyWrapper) => {169 const collectionId = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'k', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}}]});170 const itemsListIndexBefore = await getLastTokenId(api, collectionId);171 expect(itemsListIndexBefore).to.be.equal(0);172 const alice = privateKeyWrapper('//Alice');173 const bob = privateKeyWrapper('//Bob');174 await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);175 const args = [176 {NFT: {properties: [{key: 'k', value: 'v1'}]}},177 {NFT: {properties: [{key: 'k', value: 'v2'}]}},178 {NFT: {properties: [{key: 'k', value: 'v3'}]}},179 ];180181 await createMultipleItemsWithPropsExpectSuccess(alice, collectionId, args);182 const itemsListIndexAfter = await getLastTokenId(api, collectionId);183 expect(itemsListIndexAfter).to.be.equal(3);184185 expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address));186 expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address));187 expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address));188189 expect((await getTokenProperties(api, collectionId, 1, ['k']))[0].value).to.be.equal('v1');190 expect((await getTokenProperties(api, collectionId, 2, ['k']))[0].value).to.be.equal('v2');191 expect((await getTokenProperties(api, collectionId, 3, ['k']))[0].value).to.be.equal('v3');192 });193 });194195 it('Create 0x31, 0x32, 0x33 items in active NFT with property itemOwnerOrAdmin', async () => {196 await usingApi(async (api, privateKeyWrapper) => {197 const collectionId = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]});198 const itemsListIndexBefore = await getLastTokenId(api, collectionId);199 expect(itemsListIndexBefore).to.be.equal(0);200 const alice = privateKeyWrapper('//Alice');201 const args = [202 {NFT: {properties: [{key: 'k', value: 'v1'}]}},203 {NFT: {properties: [{key: 'k', value: 'v2'}]}},204 {NFT: {properties: [{key: 'k', value: 'v3'}]}},205 ];206207 await createMultipleItemsWithPropsExpectSuccess(alice, collectionId, args);208 const itemsListIndexAfter = await getLastTokenId(api, collectionId);209 expect(itemsListIndexAfter).to.be.equal(3);210211 expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(alice.address));212 expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(alice.address));213 expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(alice.address));214215 expect((await getTokenProperties(api, collectionId, 1, ['k']))[0].value).to.be.equal('v1');216 expect((await getTokenProperties(api, collectionId, 2, ['k']))[0].value).to.be.equal('v2');217 expect((await getTokenProperties(api, collectionId, 3, ['k']))[0].value).to.be.equal('v3');218 });219 });220});221222describe('Integration Test createMultipleItems(collection_id, owner, items_data) with collection admin permissions:', () => {223 let alice: IKeyringPair;224 let bob: IKeyringPair;225226 before(async () => {227 await usingApi(async (api, privateKeyWrapper) => {228 alice = privateKeyWrapper('//Alice');229 bob = privateKeyWrapper('//Bob');230 });231 });232233 it('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async () => {234 await usingApi(async (api: ApiPromise) => {235 const collectionId = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'data', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]});236 const itemsListIndexBefore = await getLastTokenId(api, collectionId);237 expect(itemsListIndexBefore).to.be.equal(0);238 await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);239 const args = [240 {NFT: {properties: [{key: 'data', value: 'v1'}]}},241 {NFT: {properties: [{key: 'data', value: 'v2'}]}},242 {NFT: {properties: [{key: 'data', value: 'v3'}]}},243 ];244 const createMultipleItemsTx = api.tx.unique245 .createMultipleItems(collectionId, normalizeAccountId(bob.address), args);246 await submitTransactionAsync(bob, createMultipleItemsTx);247 const itemsListIndexAfter = await getLastTokenId(api, collectionId);248 expect(itemsListIndexAfter).to.be.equal(3);249250 expect(await getTokenOwner(api, collectionId, 1)).to.be.deep.equal(normalizeAccountId(bob.address));251 expect(await getTokenOwner(api, collectionId, 2)).to.be.deep.equal(normalizeAccountId(bob.address));252 expect(await getTokenOwner(api, collectionId, 3)).to.be.deep.equal(normalizeAccountId(bob.address));253254 expect((await getTokenProperties(api, collectionId, 1, ['data']))[0].value).to.be.equal('v1');255 expect((await getTokenProperties(api, collectionId, 2, ['data']))[0].value).to.be.equal('v2');256 expect((await getTokenProperties(api, collectionId, 3, ['data']))[0].value).to.be.equal('v3');257 });258 });259260 it('Create 0x01, 0x02, 0x03 items in active Fungible collection and verify tokens data in chain', async () => {261 await usingApi(async (api: ApiPromise) => {262 const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});263 const itemsListIndexBefore = await getLastTokenId(api, collectionId);264 expect(itemsListIndexBefore).to.be.equal(0);265 await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);266 const args = [267 {Fungible: {value: 1}},268 {Fungible: {value: 2}},269 {Fungible: {value: 3}},270 ];271 const createMultipleItemsTx = api.tx.unique272 .createMultipleItems(collectionId, normalizeAccountId(bob.address), args);273 await submitTransactionAsync(bob, createMultipleItemsTx);274 const token1Data = await getBalance(api, collectionId, bob.address, 0);275276 expect(token1Data).to.be.equal(6n); // 1 + 2 + 3277 });278 });279280 it('Create 0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', async function() {281 await requirePallets(this, [Pallets.ReFungible]);282283 await usingApi(async (api: ApiPromise) => {284 const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});285 const itemsListIndexBefore = await getLastTokenId(api, collectionId);286 expect(itemsListIndexBefore).to.be.equal(0);287 await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);288 const args = [289 {ReFungible: {pieces: 1}},290 {ReFungible: {pieces: 2}},291 {ReFungible: {pieces: 3}},292 ];293 const createMultipleItemsTx = api.tx.unique294 .createMultipleItems(collectionId, normalizeAccountId(bob.address), args);295 await submitTransactionAsync(bob, createMultipleItemsTx);296 const itemsListIndexAfter = await getLastTokenId(api, collectionId);297 expect(itemsListIndexAfter).to.be.equal(3);298299 expect(await getBalance(api, collectionId, bob.address, 1)).to.be.equal(1n);300 expect(await getBalance(api, collectionId, bob.address, 2)).to.be.equal(2n);301 expect(await getBalance(api, collectionId, bob.address, 3)).to.be.equal(3n);302 });303 });304});305306describe('Negative Integration Test createMultipleItems(collection_id, owner, items_data):', () => {307 let alice: IKeyringPair;308 let bob: IKeyringPair;309310 before(async () => {311 await usingApi(async (api, privateKeyWrapper) => {312 alice = privateKeyWrapper('//Alice');313 bob = privateKeyWrapper('//Bob');314 });315 });316317 it('Regular user cannot create items in active NFT collection', async () => {318 await usingApi(async (api: ApiPromise) => {319 const collectionId = await createCollectionExpectSuccess();320 const itemsListIndexBefore = await getLastTokenId(api, collectionId);321 expect(itemsListIndexBefore).to.be.equal(0);322 const args = [{NFT: {}},323 {NFT: {}},324 {NFT: {}}];325 const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);326 await expect(executeTransaction(api, bob, createMultipleItemsTx)).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);327 });328 });329330 it('Regular user cannot create items in active Fungible collection', async () => {331 await usingApi(async (api: ApiPromise) => {332 const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});333 const itemsListIndexBefore = await getLastTokenId(api, collectionId);334 expect(itemsListIndexBefore).to.be.equal(0);335 const args = [336 {Fungible: {value: 1}},337 {Fungible: {value: 2}},338 {Fungible: {value: 3}},339 ];340 const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);341 await expect(executeTransaction(api, bob, createMultipleItemsTx)).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);342 });343 });344345 it('Regular user cannot create items in active ReFungible collection', async function() {346 await requirePallets(this, [Pallets.ReFungible]);347348 await usingApi(async (api: ApiPromise) => {349 const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});350 const itemsListIndexBefore = await getLastTokenId(api, collectionId);351 expect(itemsListIndexBefore).to.be.equal(0);352 const args = [353 {ReFungible: {pieces: 1}},354 {ReFungible: {pieces: 1}},355 {ReFungible: {pieces: 1}},356 ];357 const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);358 await expect(executeTransaction(api, bob, createMultipleItemsTx)).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);359 });360 });361362 it('Create token in not existing collection', async () => {363 await usingApi(async (api: ApiPromise) => {364 const collectionId = await getCreatedCollectionCount(api) + 1;365 const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), ['NFT', 'NFT', 'NFT']);366 await expect(executeTransaction(api, alice, createMultipleItemsTx)).to.be.rejectedWith(/common\.CollectionNotFound/);367 });368 });369370 it('Create NFTs that has reached the maximum data limit', async function() {371 await usingApi(async (api, privateKeyWrapper) => {372 const collectionId = await createCollectionWithPropsExpectSuccess({373 propPerm: [{key: 'key', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}],374 });375 const alice = privateKeyWrapper('//Alice');376 const args = [377 {NFT: {properties: [{key: 'key', value: 'A'.repeat(32769)}]}},378 {NFT: {properties: [{key: 'key', value: 'B'.repeat(32769)}]}},379 {NFT: {properties: [{key: 'key', value: 'C'.repeat(32769)}]}},380 ];381 const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);382 await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTx)).to.be.rejected;383 });384 });385386 it('Create Refungible tokens that has reached the maximum data limit', async function() {387 await requirePallets(this, [Pallets.ReFungible]);388389 await usingApi(async api => {390 const collectionIdReFungible =391 await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});392 {393 const argsReFungible = [394 {ReFungible: [10, [['key', 'A'.repeat(32769)]]]},395 {ReFungible: [10, [['key', 'B'.repeat(32769)]]]},396 {ReFungible: [10, [['key', 'C'.repeat(32769)]]]},397 ];398 const createMultipleItemsTxFungible = api.tx.unique399 .createMultipleItems(collectionIdReFungible, normalizeAccountId(alice.address), argsReFungible);400 await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTxFungible)).to.be.rejected;401 }402 {403 const argsReFungible = [404 {ReFungible: {properties: [{key: 'key', value: 'A'.repeat(32769)}]}},405 {ReFungible: {properties: [{key: 'key', value: 'B'.repeat(32769)}]}},406 {ReFungible: {properties: [{key: 'key', value: 'C'.repeat(32769)}]}},407 ];408 const createMultipleItemsTxFungible = api.tx.unique409 .createMultipleItems(collectionIdReFungible, normalizeAccountId(alice.address), argsReFungible);410 await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTxFungible)).to.be.rejected;411 }412 });413 });414415 it('Create tokens with different types', async () => {416 await usingApi(async (api: ApiPromise) => {417 const collectionId = await createCollectionExpectSuccess();418419 const types = ['NFT', 'Fungible'];420421 if (await checkPalletsPresence([Pallets.ReFungible])) {422 types.push('ReFungible');423 }424425 const createMultipleItemsTx = api.tx.unique426 .createMultipleItems(collectionId, normalizeAccountId(alice.address), types);427 await expect(executeTransaction(api, alice, createMultipleItemsTx)).to.be.rejectedWith(/nonfungible\.NotNonfungibleDataUsedToMintFungibleCollectionToken/);428 // garbage collection :-D // lol429 await destroyCollectionExpectSuccess(collectionId);430 });431 });432433 it('Create tokens with different data limits <> maximum data limit', async () => {434 await usingApi(async (api: ApiPromise) => {435 const collectionId = await createCollectionWithPropsExpectSuccess({436 propPerm: [{key: 'key', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}],437 });438 const args = [439 {NFT: {properties: [{key: 'key', value: 'A'}]}},440 {NFT: {properties: [{key: 'key', value: 'B'.repeat(32769)}]}},441 ];442 const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);443 await expect(submitTransactionExpectFailAsync(alice, createMultipleItemsTx)).to.be.rejected;444 });445 });446447 it('Fails when minting tokens exceeds collectionLimits amount', async () => {448 await usingApi(async (api) => {449 const collectionId = await createCollectionExpectSuccess();450 await setCollectionLimitsExpectSuccess(alice, collectionId, {451 tokenLimit: 1,452 });453 const args = [454 {NFT: {}},455 {NFT: {}},456 ];457 const createMultipleItemsTx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);458 await expect(executeTransaction(api, alice, createMultipleItemsTx)).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);459 });460 });461462 it('User doesnt have editing rights', async () => {463 await usingApi(async (api: ApiPromise) => {464 const collectionId = await createCollectionWithPropsExpectSuccess({465 propPerm: [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}],466 });467 const itemsListIndexBefore = await getLastTokenId(api, collectionId);468 expect(itemsListIndexBefore).to.be.equal(0);469 await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);470 const args = [471 {NFT: {properties: [{key: 'key1', value: 'v2'}]}},472 {NFT: {}},473 {NFT: {}},474 ];475476 const tx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(bob.address), args);477 await expect(executeTransaction(api, bob, tx)).to.be.rejectedWith(/common\.NoPermission/);478 });479 });480481 it('Adding property without access rights', async () => {482 await usingApi(async (api: ApiPromise) => {483 const collectionId = await createCollectionWithPropsExpectSuccess({properties: [{key: 'k', value: 'v1'}]});484 const itemsListIndexBefore = await getLastTokenId(api, collectionId);485 await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);486 expect(itemsListIndexBefore).to.be.equal(0);487 const args = [{NFT: {properties: [{key: 'k', value: 'v'}]}},488 {NFT: {}},489 {NFT: {}}];490491 const tx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(bob.address), args);492 await expect(executeTransaction(api, bob, tx)).to.be.rejectedWith(/common\.NoPermission/);493 });494 });495496 it('Adding more than 64 prps', async () => {497 await usingApi(async (api: ApiPromise) => {498 const propPerms = [{key: 'key', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}];499 for (let i = 0; i < 65; i++) {500 propPerms.push({key: `key${i}`, permission: {mutable: true, collectionAdmin: true, tokenOwner: true}});501 }502503 const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});504505 const tx1 = api.tx.unique.setTokenPropertyPermissions(collectionId, propPerms);506 await expect(executeTransaction(api, alice, tx1)).to.be.rejectedWith(/common\.PropertyLimitReached/);507508 const itemsListIndexBefore = await getLastTokenId(api, collectionId);509 expect(itemsListIndexBefore).to.be.equal(0);510 await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);511512 const prps = [];513514 for (let i = 0; i < 65; i++) {515 prps.push({key: `key${i}`, value: `value${i}`});516 }517518 const args = [519 {NFT: {properties: prps}},520 {NFT: {properties: prps}},521 {NFT: {properties: prps}},522 ];523524 // there are no permissions, but will fail anyway because of too much weight for a block525 const tx2 = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);526 await expect(submitTransactionExpectFailAsync(alice, tx2)).to.be.rejected;527 });528 });529530 it('Trying to add bigger property than allowed', async () => {531 await usingApi(async (api: ApiPromise) => {532 const collectionId = await createCollectionWithPropsExpectSuccess({533 propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}],534 });535 const itemsListIndexBefore = await getLastTokenId(api, collectionId);536 expect(itemsListIndexBefore).to.be.equal(0);537 const args = [{NFT: {properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]}},538 {NFT: {properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]}},539 {NFT: {properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}]}}];540541 const tx = api.tx.unique.createMultipleItems(collectionId, normalizeAccountId(alice.address), args);542 await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);543 });544 });545});1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617import {IKeyringPair} from '@polkadot/types/types';18import {usingPlaygrounds, expect, Pallets, itSub} from './util/playgrounds';1920describe('Integration Test createMultipleItems(collection_id, owner, items_data):', () => {21 let alice: IKeyringPair;2223 before(async () => {24 await usingPlaygrounds(async (helper, privateKey) => {25 const donor = privateKey('//Alice');26 [alice] = await helper.arrange.createAccounts([100n], donor);27 });28 });2930 itSub('Create 0x31, 0x32, 0x33 items in active NFT collection and verify tokens data in chain', async ({helper}) => {31 const collection = await helper.nft.mintCollection(alice, {32 name: 'name',33 description: 'descr',34 tokenPrefix: 'COL',35 tokenPropertyPermissions: [36 {key: 'data', permission: {tokenOwner: true, mutable: false, collectionAdmin: false}},37 ],38 });39 const args = [40 {properties: [{key: 'data', value: '1'}]},41 {properties: [{key: 'data', value: '2'}]},42 {properties: [{key: 'data', value: '3'}]},43 ];44 const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);45 for (const [i, token] of tokens.entries()) {46 const tokenData = await token.getData();47 expect(tokenData?.normalizedOwner.Substrate).to.be.deep.equal(helper.address.normalizeSubstrate(alice.address));48 expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);49 }50 });5152 itSub('Create 0x01, 0x02, 0x03 items in active Fungible collection and verify tokens data in chain', async ({helper}) => {53 const collection = await helper.ft.mintCollection(alice, {54 name: 'name',55 description: 'descr',56 tokenPrefix: 'COL',57 });58 const args = [59 {value: 1n},60 {value: 2n},61 {value: 3n},62 ];63 await helper.ft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, args, {Substrate: alice.address});64 expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(6n);65 });6667 itSub.ifWithPallets('Create 0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', [Pallets.ReFungible], async ({helper}) => {68 const collection = await helper.rft.mintCollection(alice, {69 name: 'name',70 description: 'descr',71 tokenPrefix: 'COL',72 });73 const args = [74 {pieces: 1n},75 {pieces: 2n},76 {pieces: 3n},77 ];78 const tokens = await helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);7980 for (const [i, token] of tokens.entries()) {81 expect(await token.getBalance({Substrate: alice.address})).to.be.equal(BigInt(i + 1));82 }83 });8485 itSub('Can mint amount of items equals to collection limits', async ({helper}) => {86 const collection = await helper.nft.mintCollection(alice, {87 name: 'name',88 description: 'descr',89 tokenPrefix: 'COL',90 limits: {91 tokenLimit: 2,92 },93 });94 const args = [{}, {}];95 await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);96 });9798 itSub('Create 0x31, 0x32, 0x33 items in active NFT with property Admin', async ({helper}) => {99 const collection = await helper.nft.mintCollection(alice, {100 name: 'name',101 description: 'descr',102 tokenPrefix: 'COL',103 tokenPropertyPermissions: [104 {key: 'data', permission: {tokenOwner: false, mutable: true, collectionAdmin: true}},105 ],106 });107 const args = [108 {properties: [{key: 'data', value: '1'}]},109 {properties: [{key: 'data', value: '2'}]},110 {properties: [{key: 'data', value: '3'}]},111 ];112 const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);113 for (const [i, token] of tokens.entries()) {114 const tokenData = await token.getData();115 expect(tokenData?.normalizedOwner.Substrate).to.be.deep.equal(helper.address.normalizeSubstrate(alice.address));116 expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);117 }118 });119120 itSub('Create 0x31, 0x32, 0x33 items in active NFT with property AdminConst', async ({helper}) => {121 const collection = await helper.nft.mintCollection(alice, {122 name: 'name',123 description: 'descr',124 tokenPrefix: 'COL',125 tokenPropertyPermissions: [126 {key: 'data', permission: {tokenOwner: false, mutable: false, collectionAdmin: true}},127 ],128 });129 const args = [130 {properties: [{key: 'data', value: '1'}]},131 {properties: [{key: 'data', value: '2'}]},132 {properties: [{key: 'data', value: '3'}]},133 ];134 const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);135 for (const [i, token] of tokens.entries()) {136 const tokenData = await token.getData();137 expect(tokenData?.normalizedOwner.Substrate).to.be.deep.equal(helper.address.normalizeSubstrate(alice.address));138 expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);139 }140 });141142 itSub('Create 0x31, 0x32, 0x33 items in active NFT with property itemOwnerOrAdmin', async ({helper}) => {143 const collection = await helper.nft.mintCollection(alice, {144 name: 'name',145 description: 'descr',146 tokenPrefix: 'COL',147 tokenPropertyPermissions: [148 {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},149 ],150 });151 const args = [152 {properties: [{key: 'data', value: '1'}]},153 {properties: [{key: 'data', value: '2'}]},154 {properties: [{key: 'data', value: '3'}]},155 ];156 const tokens = await helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);157 for (const [i, token] of tokens.entries()) {158 const tokenData = await token.getData();159 expect(tokenData?.normalizedOwner.Substrate).to.be.equal(helper.address.normalizeSubstrate(alice.address));160 expect(tokenData?.properties[0].value).to.be.equal(args[i].properties[0].value);161 }162 });163});164165describe('Negative Integration Test createMultipleItems(collection_id, owner, items_data):', () => {166 let alice: IKeyringPair;167 let bob: IKeyringPair;168169 before(async () => {170 await usingPlaygrounds(async (helper, privateKey) => {171 const donor = privateKey('//Alice');172 [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);173 });174 });175176 itSub('Regular user cannot create items in active NFT collection', async ({helper}) => {177 const collection = await helper.nft.mintCollection(alice, {178 name: 'name',179 description: 'descr',180 tokenPrefix: 'COL',181 });182 const args = [183 {},184 {},185 ];186 const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);187 await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);188 });189190 itSub('Regular user cannot create items in active Fungible collection', async ({helper}) => {191 const collection = await helper.ft.mintCollection(alice, {192 name: 'name',193 description: 'descr',194 tokenPrefix: 'COL',195 });196 const args = [197 {value: 1n},198 {value: 2n},199 {value: 3n},200 ];201 const mintTx = async () => helper.ft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, args, {Substrate: alice.address});202 await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);203 });204205 itSub.ifWithPallets('Regular user cannot create items in active ReFungible collection', [Pallets.ReFungible], async ({helper}) => {206 const collection = await helper.rft.mintCollection(alice, {207 name: 'name',208 description: 'descr',209 tokenPrefix: 'COL',210 });211 const args = [212 {pieces: 1n},213 {pieces: 1n},214 {pieces: 1n},215 ];216 const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(bob, collection.collectionId, {Substrate: alice.address}, args);217 await expect(mintTx()).to.be.rejectedWith(/common\.PublicMintingNotAllowed/);218 });219220 itSub('Create token in not existing collection', async ({helper}) => {221 const collectionId = 1_000_000;222 const args = [223 {},224 {},225 ];226 const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(bob, collectionId, {Substrate: alice.address}, args);227 await expect(mintTx()).to.be.rejectedWith(/common\.CollectionNotFound/);228 });229230 itSub('Create NFTs that has reached the maximum data limit', async ({helper}) => {231 const collection = await helper.nft.mintCollection(alice, {232 name: 'name',233 description: 'descr',234 tokenPrefix: 'COL',235 tokenPropertyPermissions: [236 {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},237 ],238 });239 const args = [240 {properties: [{key: 'data', value: 'A'.repeat(32769)}]},241 {properties: [{key: 'data', value: 'B'.repeat(32769)}]},242 {properties: [{key: 'data', value: 'C'.repeat(32769)}]},243 ];244 const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);245 await expect(mintTx()).to.be.rejectedWith('Verification Error');246 });247248 itSub.ifWithPallets('Create Refungible tokens that has reached the maximum data limit', [Pallets.ReFungible], async ({helper}) => {249 const collection = await helper.rft.mintCollection(alice, {250 name: 'name',251 description: 'descr',252 tokenPrefix: 'COL',253 tokenPropertyPermissions: [254 {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},255 ],256 });257 const args = [258 {pieces: 10n, properties: [{key: 'data', value: 'A'.repeat(32769)}]},259 {pieces: 10n, properties: [{key: 'data', value: 'B'.repeat(32769)}]},260 {pieces: 10n, properties: [{key: 'data', value: 'C'.repeat(32769)}]},261 ];262 const mintTx = async () => helper.rft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);263 await expect(mintTx()).to.be.rejectedWith('Verification Error');264 });265266 itSub.ifWithPallets('Create tokens with different types', [Pallets.ReFungible], async ({helper}) => {267 const {collectionId} = await helper.nft.mintCollection(alice, {268 name: 'name',269 description: 'descr',270 tokenPrefix: 'COL',271 });272273 const types = ['NFT', 'Fungible', 'ReFungible'];274 await expect(helper.executeExtrinsic(275 alice, 276 'api.tx.unique.createMultipleItems', 277 [collectionId, {Substrate: alice.address}, types],278 )).to.be.rejectedWith(/nonfungible\.NotNonfungibleDataUsedToMintFungibleCollectionToken/);279 });280281 itSub('Create tokens with different data limits <> maximum data limit', async ({helper}) => {282 const collection = await helper.nft.mintCollection(alice, {283 name: 'name',284 description: 'descr',285 tokenPrefix: 'COL',286 tokenPropertyPermissions: [287 {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},288 ],289 });290 const args = [291 {properties: [{key: 'data', value: 'A'}]},292 {properties: [{key: 'data', value: 'B'.repeat(32769)}]},293 ];294 const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);295 await expect(mintTx()).to.be.rejectedWith('Verification Error');296 });297298 itSub('Fails when minting tokens exceeds collectionLimits amount', async ({helper}) => {299 const collection = await helper.nft.mintCollection(alice, {300 name: 'name',301 description: 'descr',302 tokenPrefix: 'COL',303 tokenPropertyPermissions: [304 {key: 'data', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},305 ],306 limits: {307 tokenLimit: 1,308 },309 });310 const args = [311 {},312 {},313 ];314 const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);315 await expect(mintTx()).to.be.rejectedWith(/common\.CollectionTokenLimitExceeded/);316 });317318 itSub('User doesnt have editing rights', async ({helper}) => {319 const collection = await helper.nft.mintCollection(alice, {320 name: 'name',321 description: 'descr',322 tokenPrefix: 'COL',323 tokenPropertyPermissions: [324 {key: 'data', permission: {tokenOwner: false, mutable: true, collectionAdmin: false}},325 ],326 });327 const args = [328 {properties: [{key: 'data', value: 'A'}]},329 ];330 const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);331 await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);332 });333334 itSub('Adding property without access rights', async ({helper}) => {335 const collection = await helper.nft.mintCollection(alice, {336 name: 'name',337 description: 'descr',338 tokenPrefix: 'COL',339 properties: [340 {341 key: 'data',342 value: 'v',343 },344 ],345 });346 const args = [347 {properties: [{key: 'data', value: 'A'}]},348 ];349 const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);350 await expect(mintTx()).to.be.rejectedWith(/common\.NoPermission/);351 });352353 itSub('Adding more than 64 prps', async ({helper}) => {354 const collection = await helper.nft.mintCollection(alice, {355 name: 'name',356 description: 'descr',357 tokenPrefix: 'COL',358 });359 const prps = [];360361 for (let i = 0; i < 65; i++) {362 prps.push({key: `key${i}`, value: `value${i}`});363 }364365 const args = [366 {properties: prps},367 {properties: prps},368 {properties: prps},369 ];370371 const mintTx = async () => helper.nft.mintMultipleTokensWithOneOwner(alice, collection.collectionId, {Substrate: alice.address}, args);372 await expect(mintTx()).to.be.rejectedWith('Verification Error');373 });374});tests/src/createMultipleItemsEx.test.tsdiffbeforeafterboth--- a/tests/src/createMultipleItemsEx.test.ts
+++ b/tests/src/createMultipleItemsEx.test.ts
@@ -14,382 +14,433 @@
// You should have received a copy of the GNU General Public License
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-import {expect} from 'chai';
-import usingApi, {executeTransaction} from './substrate/substrate-api';
-import {addCollectionAdminExpectSuccess, createCollectionExpectSuccess, createCollectionWithPropsExpectSuccess, getBalance, getLastTokenId, getTokenProperties, requirePallets, Pallets} from './util/helpers';
+import {IKeyringPair} from '@polkadot/types/types';
+import {usingPlaygrounds, expect, Pallets, itSub} from './util/playgrounds';
+import {IProperty} from './util/playgrounds/types';
describe('Integration Test: createMultipleItemsEx', () => {
- it('can initialize multiple NFT with different owners', async () => {
- const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- const data = [
- {
- owner: {substrate: alice.address},
- }, {
- owner: {substrate: bob.address},
- }, {
- owner: {substrate: charlie.address},
- },
- ];
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+ let charlie: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
+ });
+ });
- await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
- NFT: data,
- }));
- const tokens = await api.query.nonfungible.tokenData.entries(collection);
- const json = tokens.map(([, token]) => token.toJSON());
- expect(json).to.be.deep.equal(data);
+ itSub('can initialize multiple NFT with different owners', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
});
+ const args = [
+ {
+ owner: {Substrate: alice.address},
+ },
+ {
+ owner: {Substrate: bob.address},
+ },
+ {
+ owner: {Substrate: charlie.address},
+ },
+ ];
+
+ const tokens = await collection.mintMultipleTokens(alice, args);
+ for (const [i, token] of tokens.entries()) {
+ expect(await token.getOwner()).to.be.deep.equal(args[i].owner);
+ }
});
- it('createMultipleItemsEx with property Admin', async () => {
- const collection = await createCollectionWithPropsExpectSuccess({mode: {type: 'NFT'}, propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: false}}]});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- const data = [
+ itSub('createMultipleItemsEx with property Admin', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
{
- owner: {substrate: alice.address},
- properties: [{key: 'k', value: 'v1'}],
- }, {
- owner: {substrate: bob.address},
- properties: [{key: 'k', value: 'v2'}],
- }, {
- owner: {substrate: charlie.address},
- properties: [{key: 'k', value: 'v3'}],
+ key: 'k',
+ permission: {
+ mutable: true,
+ collectionAdmin: true,
+ tokenOwner: false,
+ },
},
- ];
+ ],
+ });
- await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
- NFT: data,
- }));
- for (let i = 1; i < 4; i++) {
- expect(await api.rpc.unique.tokenProperties(collection, i)).not.to.be.empty;
- }
- });
+ const args = [
+ {
+ owner: {Substrate: alice.address},
+ properties: [{key: 'k', value: 'v1'}],
+ },
+ {
+ owner: {Substrate: bob.address},
+ properties: [{key: 'k', value: 'v2'}],
+ },
+ {
+ owner: {Substrate: charlie.address},
+ properties: [{key: 'k', value: 'v3'}],
+ },
+ ];
+
+ const tokens = await collection.mintMultipleTokens(alice, args);
+ for (const [i, token] of tokens.entries()) {
+ expect(await token.getOwner()).to.be.deep.equal(args[i].owner);
+ expect(await token.getData()).to.not.be.empty;
+ }
});
- it('createMultipleItemsEx with property AdminConst', async () => {
- const collection = await createCollectionWithPropsExpectSuccess({mode: {type: 'NFT'}, propPerm: [{key: 'k', permission: {mutable: false, collectionAdmin: true, tokenOwner: false}}]});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- const data = [
+ itSub('createMultipleItemsEx with property AdminConst', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
{
- owner: {substrate: alice.address},
- properties: [{key: 'k', value: 'v1'}],
- }, {
- owner: {substrate: bob.address},
- properties: [{key: 'k', value: 'v2'}],
- }, {
- owner: {substrate: charlie.address},
- properties: [{key: 'k', value: 'v3'}],
+ key: 'k',
+ permission: {
+ mutable: false,
+ collectionAdmin: true,
+ tokenOwner: false,
+ },
},
- ];
+ ],
+ });
- await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
- NFT: data,
- }));
- for (let i = 1; i < 4; i++) {
- expect(await api.rpc.unique.tokenProperties(collection, i)).not.to.be.empty;
- }
- });
+ const args = [
+ {
+ owner: {Substrate: alice.address},
+ properties: [{key: 'k', value: 'v1'}],
+ },
+ {
+ owner: {Substrate: bob.address},
+ properties: [{key: 'k', value: 'v2'}],
+ },
+ {
+ owner: {Substrate: charlie.address},
+ properties: [{key: 'k', value: 'v3'}],
+ },
+ ];
+
+ const tokens = await collection.mintMultipleTokens(alice, args);
+ for (const [i, token] of tokens.entries()) {
+ expect(await token.getOwner()).to.be.deep.equal(args[i].owner);
+ expect(await token.getData()).to.not.be.empty;
+ }
});
- it('createMultipleItemsEx with property itemOwnerOrAdmin', async () => {
- const collection = await createCollectionWithPropsExpectSuccess({mode: {type: 'NFT'}, propPerm: [{key: 'k', permission: {mutable: false, collectionAdmin: true, tokenOwner: true}}]});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- const data = [
+ itSub('createMultipleItemsEx with property itemOwnerOrAdmin', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
{
- owner: {substrate: alice.address},
- properties: [{key: 'k', value: 'v1'}],
- }, {
- owner: {substrate: bob.address},
- properties: [{key: 'k', value: 'v2'}],
- }, {
- owner: {substrate: charlie.address},
- properties: [{key: 'k', value: 'v3'}],
+ key: 'k',
+ permission: {
+ mutable: false,
+ collectionAdmin: true,
+ tokenOwner: true,
+ },
},
- ];
+ ],
+ });
+
+ const args = [
+ {
+ owner: {Substrate: alice.address},
+ properties: [{key: 'k', value: 'v1'}],
+ },
+ {
+ owner: {Substrate: bob.address},
+ properties: [{key: 'k', value: 'v2'}],
+ },
+ {
+ owner: {Substrate: charlie.address},
+ properties: [{key: 'k', value: 'v3'}],
+ },
+ ];
- await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
- NFT: data,
- }));
- for (let i = 1; i < 4; i++) {
- expect(await api.rpc.unique.tokenProperties(collection, i)).not.to.be.empty;
- }
- });
+ const tokens = await collection.mintMultipleTokens(alice, args);
+ for (const [i, token] of tokens.entries()) {
+ expect(await token.getOwner()).to.be.deep.equal(args[i].owner);
+ expect(await token.getData()).to.not.be.empty;
+ }
});
- it('can initialize fungible with multiple owners', async () => {
- const collection = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
+ itSub('can initialize fungible with multiple owners', async ({helper}) => {
+ const collection = await helper.ft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ }, 0);
- await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
- Fungible: new Map([
- [JSON.stringify({Substrate: alice.address}), 50],
- [JSON.stringify({Substrate: bob.address}), 100],
- ]),
- }));
+ const api = helper.api;
+ await helper.signTransaction(alice, api?.tx.unique.createMultipleItemsEx(collection.collectionId, {
+ Fungible: new Map([
+ [JSON.stringify({Substrate: alice.address}), 50],
+ [JSON.stringify({Substrate: bob.address}), 100],
+ ]),
+ }));
- expect(await getBalance(api, collection, alice.address, 0)).to.equal(50n);
- expect(await getBalance(api, collection, bob.address, 0)).to.equal(100n);
+ expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(50n);
+ expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(100n);
+ });
+
+ itSub.ifWithPallets('can initialize an RFT with multiple owners', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
+ {key: 'k', permission: {tokenOwner: true, mutable: false, collectionAdmin: false}},
+ ],
});
+
+ const api = helper.api;
+ await helper.signTransaction(alice, api?.tx.unique.createMultipleItemsEx(collection.collectionId, {
+ RefungibleMultipleOwners: {
+ users: new Map([
+ [JSON.stringify({Substrate: alice.address}), 1],
+ [JSON.stringify({Substrate: bob.address}), 2],
+ ]),
+ properties: [
+ {key: 'k', value: 'v'},
+ ],
+ },
+ }));
+ const tokenId = await collection.getLastTokenId();
+ expect(tokenId).to.be.equal(1);
+ expect(await collection.getTokenBalance(1, {Substrate: alice.address})).to.be.equal(1n);
+ expect(await collection.getTokenBalance(1, {Substrate: bob.address})).to.be.equal(2n);
});
- it('can initialize an RFT with multiple owners', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
+ itSub.ifWithPallets('can initialize multiple RFTs with the same owner', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
+ {key: 'k', permission: {tokenOwner: true, mutable: false, collectionAdmin: false}},
+ ],
+ });
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
- await executeTransaction(
- api,
- alice,
- api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'data', permission: {tokenOwner: true}}]),
- );
+ const api = helper.api;
- await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
- RefungibleMultipleOwners: {
- users: new Map([
- [JSON.stringify({Substrate: alice.address}), 1],
- [JSON.stringify({Substrate: bob.address}), 2],
- ]),
+ await helper.signTransaction(alice, api?.tx.unique.createMultipleItemsEx(collection.collectionId, {
+ RefungibleMultipleItems: [
+ {
+ user: {Substrate: alice.address}, pieces: 1,
properties: [
- {key: 'data', value: 'testValue'},
+ {key: 'k', value: 'v1'},
],
},
- }));
-
- const itemsListIndexAfter = await getLastTokenId(api, collection);
- expect(itemsListIndexAfter).to.be.equal(1);
-
- expect(await getBalance(api, collection, alice.address, 1)).to.be.equal(1n);
- expect(await getBalance(api, collection, bob.address, 1)).to.be.equal(2n);
- expect((await getTokenProperties(api, collection, 1, ['data']))[0].value).to.be.equal('testValue');
- });
- });
-
- it('can initialize multiple RFTs with the same owner', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
-
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const collection = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
- await executeTransaction(
- api,
- alice,
- api.tx.unique.setTokenPropertyPermissions(collection, [{key: 'data', permission: {tokenOwner: true}}]),
- );
+ {
+ user: {Substrate: alice.address}, pieces: 3,
+ properties: [
+ {key: 'k', value: 'v2'},
+ ],
+ },
+ ],
+ }));
- await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
- RefungibleMultipleItems: [
- {
- user: {Substrate: alice.address}, pieces: 1,
- properties: [
- {key: 'data', value: 'testValue1'},
- ],
- },
- {
- user: {Substrate: alice.address}, pieces: 3,
- properties: [
- {key: 'data', value: 'testValue2'},
- ],
- },
- ],
- }));
+ expect(await collection.getLastTokenId()).to.be.equal(2);
+ expect(await collection.getTokenBalance(1, {Substrate: alice.address})).to.be.equal(1n);
+ expect(await collection.getTokenBalance(2, {Substrate: alice.address})).to.be.equal(3n);
- const itemsListIndexAfter = await getLastTokenId(api, collection);
- expect(itemsListIndexAfter).to.be.equal(2);
+ const tokenData1 = await helper.rft.getToken(collection.collectionId, 1);
+ expect(tokenData1).to.not.be.null;
+ expect(tokenData1?.properties[0]).to.be.deep.equal({key: 'k', value: 'v1'});
- expect(await getBalance(api, collection, alice.address, 1)).to.be.equal(1n);
- expect(await getBalance(api, collection, alice.address, 2)).to.be.equal(3n);
- expect((await getTokenProperties(api, collection, 1, ['data']))[0].value).to.be.equal('testValue1');
- expect((await getTokenProperties(api, collection, 2, ['data']))[0].value).to.be.equal('testValue2');
- });
+ const tokenData2 = await helper.rft.getToken(collection.collectionId, 2);
+ expect(tokenData2).to.not.be.null;
+ expect(tokenData2?.properties[0]).to.be.deep.equal({key: 'k', value: 'v2'});
});
});
describe('Negative test: createMultipleItemsEx', () => {
- it('No editing rights', async () => {
- const collection = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}],
- propPerm: [{key: 'key1', permission: {mutable: true, collectionAdmin: false, tokenOwner: false}}]});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- await addCollectionAdminExpectSuccess(alice, collection, bob.address);
- const data = [
- {
- owner: {substrate: alice.address},
- properties: [{key: 'key1', value: 'v2'}],
- }, {
- owner: {substrate: bob.address},
- properties: [{key: 'key1', value: 'v2'}],
- }, {
- owner: {substrate: charlie.address},
- properties: [{key: 'key1', value: 'v2'}],
- },
- ];
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+ let charlie: IKeyringPair;
- const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data});
- // await executeTransaction(api, alice, tx);
-
- //await submitTransactionExpectFailAsync(alice, tx);
- await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor);
});
});
- it('User doesnt have editing rights', async () => {
- const collection = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}],
- propPerm: [{key: 'key1', permission: {mutable: false, collectionAdmin: false, tokenOwner: false}}]});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- await addCollectionAdminExpectSuccess(alice, collection, bob.address);
- const data = [
+ itSub('No editing rights', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
{
- owner: {substrate: alice.address},
- properties: [{key: 'key1', value: 'v2'}],
- }, {
- owner: {substrate: alice.address},
- properties: [{key: 'key1', value: 'v2'}],
- }, {
- owner: {substrate: alice.address},
- properties: [{key: 'key1', value: 'v2'}],
+ key: 'k',
+ permission: {
+ mutable: true,
+ collectionAdmin: false,
+ tokenOwner: false,
+ },
},
- ];
+ ],
+ });
- const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data});
- // await executeTransaction(api, alice, tx);
+ const args = [
+ {
+ owner: {Substrate: alice.address},
+ properties: [{key: 'k', value: 'v1'}],
+ },
+ {
+ owner: {Substrate: bob.address},
+ properties: [{key: 'k', value: 'v2'}],
+ },
+ {
+ owner: {Substrate: charlie.address},
+ properties: [{key: 'k', value: 'v3'}],
+ },
+ ];
- //await submitTransactionExpectFailAsync(alice, tx);
- await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);
- });
+ await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith(/common\.NoPermission/);
});
- it('Adding property without access rights', async () => {
- const collection = await createCollectionWithPropsExpectSuccess({properties: [{key: 'key1', value: 'v'}]});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- await addCollectionAdminExpectSuccess(alice, collection, bob.address);
- const data = [
+ itSub('User doesnt have editing rights', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
{
- owner: {substrate: alice.address},
- properties: [{key: 'key1', value: 'v2'}],
- }, {
- owner: {substrate: bob.address},
- properties: [{key: 'key1', value: 'v2'}],
- }, {
- owner: {substrate: charlie.address},
- properties: [{key: 'key1', value: 'v2'}],
+ key: 'k',
+ permission: {
+ mutable: false,
+ collectionAdmin: false,
+ tokenOwner: false,
+ },
},
- ];
+ ],
+ });
- const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data});
+ const args = [
+ {
+ owner: {Substrate: alice.address},
+ properties: [{key: 'k', value: 'v1'}],
+ },
+ {
+ owner: {Substrate: bob.address},
+ properties: [{key: 'k', value: 'v2'}],
+ },
+ {
+ owner: {Substrate: charlie.address},
+ properties: [{key: 'k', value: 'v3'}],
+ },
+ ];
- await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);
- //await submitTransactionExpectFailAsync(alice, tx);
- });
+ await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith(/common\.NoPermission/);
});
- it('Adding more than 64 properties', async () => {
- const propPerms = [{key: 'key', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}];
+ itSub('Adding property without access rights', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ });
- for (let i = 0; i < 65; i++) {
- propPerms.push({key: `key${i}`, permission: {mutable: true, collectionAdmin: true, tokenOwner: true}});
- }
+ const args = [
+ {
+ owner: {Substrate: alice.address},
+ properties: [{key: 'k', value: 'v1'}],
+ },
+ {
+ owner: {Substrate: bob.address},
+ properties: [{key: 'k', value: 'v2'}],
+ },
+ {
+ owner: {Substrate: charlie.address},
+ properties: [{key: 'k', value: 'v3'}],
+ },
+ ];
- const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- await expect(executeTransaction(api, alice, api.tx.unique.setTokenPropertyPermissions(collection, propPerms))).to.be.rejectedWith(/common\.PropertyLimitReached/);
- });
+ await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith(/common\.NoPermission/);
});
- it('Trying to add bigger property than allowed', async () => {
- const collection = await createCollectionWithPropsExpectSuccess({propPerm: [{key: 'k', permission: {mutable: true, collectionAdmin: true, tokenOwner: true}}]});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- await addCollectionAdminExpectSuccess(alice, collection, bob.address);
- const data = [
+ itSub('Adding more than 64 properties', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
{
- owner: {substrate: alice.address}, properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}],
- }, {
- owner: {substrate: bob.address}, properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}],
- }, {
- owner: {substrate: charlie.address}, properties: [{key: 'k', value: 'vvvvvv'.repeat(5000)}, {key: 'k2', value: 'vvv'.repeat(5000)}],
+ key: 'k',
+ permission: {
+ mutable: true,
+ collectionAdmin: true,
+ tokenOwner: true,
+ },
},
- ];
+ ],
+ });
+
+ const properties: IProperty[] = [];
+
+ for (let i = 0; i < 65; i++) {
+ properties.push({key: `k${i}`, value: `v${i}`});
+ }
- const tx = api.tx.unique.createMultipleItemsEx(collection, {NFT: data});
+ const args = [
+ {
+ owner: {Substrate: alice.address},
+ properties: properties,
+ },
+ {
+ owner: {Substrate: bob.address},
+ properties: properties,
+ },
+ {
+ owner: {Substrate: charlie.address},
+ properties: properties,
+ },
+ ];
- //await submitTransactionExpectFailAsync(alice, tx);
- await expect(executeTransaction(api, alice, tx)).to.be.rejectedWith(/common\.NoPermission/);
- });
+ await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith('Verification Error');
});
- it('can initialize multiple NFT with different owners', async () => {
- const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- const data = [
+ itSub('Trying to add bigger property than allowed', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'name',
+ description: 'descr',
+ tokenPrefix: 'COL',
+ tokenPropertyPermissions: [
{
- owner: {substrate: alice.address},
- }, {
- owner: {substrate: bob.address},
- }, {
- owner: {substrate: charlie.address},
+ key: 'k',
+ permission: {
+ mutable: true,
+ collectionAdmin: true,
+ tokenOwner: true,
+ },
},
- ];
-
- await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
- NFT: data,
- }));
- const tokens = await api.query.nonfungible.tokenData.entries(collection);
- const json = tokens.map(([, token]) => token.toJSON());
- expect(json).to.be.deep.equal(data);
+ ],
});
- });
- it('can initialize multiple NFT with different owners', async () => {
- const collection = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- const charlie = privateKeyWrapper('//Charlie');
- const data = [
- {
- owner: {substrate: alice.address},
- }, {
- owner: {substrate: bob.address},
- }, {
- owner: {substrate: charlie.address},
- },
- ];
+ const args = [
+ {
+ owner: {Substrate: alice.address},
+ properties: [{key: 'k', value: 'A'.repeat(32769)}],
+ },
+ {
+ owner: {Substrate: bob.address},
+ properties: [{key: 'k', value: 'A'.repeat(32769)}],
+ },
+ {
+ owner: {Substrate: charlie.address},
+ properties: [{key: 'k', value: 'A'.repeat(32769)}],
+ },
+ ];
- await executeTransaction(api, alice, api.tx.unique.createMultipleItemsEx(collection, {
- NFT: data,
- }));
- const tokens = await api.query.nonfungible.tokenData.entries(collection);
- const json = tokens.map(([, token]) => token.toJSON());
- expect(json).to.be.deep.equal(data);
- });
+ await expect(collection.mintMultipleTokens(alice, args)).to.be.rejectedWith('Verification Error');
});
});
tests/src/creditFeesToTreasury.test.tsdiffbeforeafterboth--- a/tests/src/creditFeesToTreasury.test.ts
+++ b/tests/src/creditFeesToTreasury.test.ts
@@ -15,32 +15,15 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
import './interfaces/augment-api-consts';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
import {IKeyringPair} from '@polkadot/types/types';
-import {
- createCollectionExpectSuccess,
- createItemExpectSuccess,
- getGenericResult,
- transferExpectSuccess,
- UNIQUE,
-} from './util/helpers';
-
-import {default as waitNewBlocks} from './substrate/wait-new-blocks';
import {ApiPromise} from '@polkadot/api';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {usingPlaygrounds, expect, itSub} from './util/playgrounds';
const TREASURY = '5EYCAe5ijiYfyeZ2JJCGq56LmPyNRAKzpG4QkoQkkQNB5e6Z';
const saneMinimumFee = 0.05;
const saneMaximumFee = 0.5;
const createCollectionDeposit = 100;
-let alice: IKeyringPair;
-let bob: IKeyringPair;
-
// Skip the inflation block pauses if the block is close to inflation block
// until the inflation happens
/*eslint no-async-promise-executor: "off"*/
@@ -62,129 +45,121 @@
}
describe('integration test: Fees must be credited to Treasury:', () => {
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
before(async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- alice = privateKeyWrapper('//Alice');
- bob = privateKeyWrapper('//Bob');
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
});
});
- it('Total issuance does not change', async () => {
- await usingApi(async (api) => {
- await skipInflationBlock(api);
- await waitNewBlocks(api, 1);
+ itSub('Total issuance does not change', async ({helper}) => {
+ const api = helper.api!;
+ await skipInflationBlock(api);
+ await helper.wait.newBlocks(1);
- const totalBefore = (await api.query.balances.totalIssuance()).toBigInt();
+ const totalBefore = (await api.query.balances.totalIssuance()).toBigInt();
- const amount = 1n;
- const transfer = api.tx.balances.transfer(bob.address, amount);
+ await helper.balance.transferToSubstrate(alice, bob.address, 1n);
- const result = getGenericResult(await submitTransactionAsync(alice, transfer));
+ const totalAfter = (await api.query.balances.totalIssuance()).toBigInt();
- const totalAfter = (await api.query.balances.totalIssuance()).toBigInt();
+ expect(totalAfter).to.be.equal(totalBefore);
+ });
- expect(result.success).to.be.true;
- expect(totalAfter).to.be.equal(totalBefore);
- });
- });
+ itSub('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async ({helper}) => {
+ await skipInflationBlock(helper.api!);
+ await helper.wait.newBlocks(1);
- it('Sender balance decreased by fee+sent amount, Treasury balance increased by fee', async () => {
- await usingApi(async (api) => {
- await skipInflationBlock(api);
- await waitNewBlocks(api, 1);
+ const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
+ const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
- const treasuryBalanceBefore: bigint = (await api.query.system.account(TREASURY)).data.free.toBigInt();
- const aliceBalanceBefore: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
+ const amount = 1n;
+ await helper.balance.transferToSubstrate(alice, bob.address, amount);
- const amount = 1n;
- const transfer = api.tx.balances.transfer(bob.address, amount);
- const result = getGenericResult(await submitTransactionAsync(alice, transfer));
+ const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
+ const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
- const treasuryBalanceAfter: bigint = (await api.query.system.account(TREASURY)).data.free.toBigInt();
- const aliceBalanceAfter: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
- const fee = aliceBalanceBefore - aliceBalanceAfter - amount;
- const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
+ const fee = aliceBalanceBefore - aliceBalanceAfter - amount;
+ const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
- expect(result.success).to.be.true;
- expect(treasuryIncrease).to.be.equal(fee);
- });
+ expect(treasuryIncrease).to.be.equal(fee);
});
- it('Treasury balance increased by failed tx fee', async () => {
- await usingApi(async (api) => {
- //await skipInflationBlock(api);
- await waitNewBlocks(api, 1);
+ itSub('Treasury balance increased by failed tx fee', async ({helper}) => {
+ const api = helper.api!;
+ await helper.wait.newBlocks(1);
- const treasuryBalanceBefore = (await api.query.system.account(TREASURY)).data.free.toBigInt();
- const bobBalanceBefore = (await api.query.system.account(bob.address)).data.free.toBigInt();
+ const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
+ const bobBalanceBefore = await helper.balance.getSubstrate(bob.address);
- const badTx = api.tx.balances.setBalance(alice.address, 0, 0);
- await expect(submitTransactionExpectFailAsync(bob, badTx)).to.be.rejected;
+ await expect(helper.signTransaction(bob, api.tx.balances.setBalance(alice.address, 0, 0))).to.be.rejected;
+
+ const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
+ const bobBalanceAfter = await helper.balance.getSubstrate(bob.address);
- const treasuryBalanceAfter = (await api.query.system.account(TREASURY)).data.free.toBigInt();
- const bobBalanceAfter = (await api.query.system.account(bob.address)).data.free.toBigInt();
- const fee = bobBalanceBefore - bobBalanceAfter;
- const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
+ const fee = bobBalanceBefore - bobBalanceAfter;
+ const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
- expect(treasuryIncrease).to.be.equal(fee);
- });
+ expect(treasuryIncrease).to.be.equal(fee);
});
- it('NFT Transactions also send fees to Treasury', async () => {
- await usingApi(async (api) => {
- await skipInflationBlock(api);
- await waitNewBlocks(api, 1);
+ itSub('NFT Transactions also send fees to Treasury', async ({helper}) => {
+ await skipInflationBlock(helper.api!);
+ await helper.wait.newBlocks(1);
- const treasuryBalanceBefore = (await api.query.system.account(TREASURY)).data.free.toBigInt();
- const aliceBalanceBefore = (await api.query.system.account(alice.address)).data.free.toBigInt();
+ const treasuryBalanceBefore = await helper.balance.getSubstrate(TREASURY);
+ const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
- await createCollectionExpectSuccess();
+ await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
- const treasuryBalanceAfter = (await api.query.system.account(TREASURY)).data.free.toBigInt();
- const aliceBalanceAfter = (await api.query.system.account(alice.address)).data.free.toBigInt();
- const fee = aliceBalanceBefore - aliceBalanceAfter;
- const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
+ const treasuryBalanceAfter = await helper.balance.getSubstrate(TREASURY);
+ const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
+ const fee = aliceBalanceBefore - aliceBalanceAfter;
+ const treasuryIncrease = treasuryBalanceAfter - treasuryBalanceBefore;
- expect(treasuryIncrease).to.be.equal(fee);
- });
+ expect(treasuryIncrease).to.be.equal(fee);
});
- it('Fees are sane', async () => {
- await usingApi(async (api) => {
- await skipInflationBlock(api);
- await waitNewBlocks(api, 1);
+ itSub('Fees are sane', async ({helper}) => {
+ const unique = helper.balance.getOneTokenNominal();
+ await skipInflationBlock(helper.api!);
+ await helper.wait.newBlocks(1);
- const aliceBalanceBefore: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
+ const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
- await createCollectionExpectSuccess();
+ await helper.nft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
- const aliceBalanceAfter: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
- const fee = aliceBalanceBefore - aliceBalanceAfter;
+ const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
+ const fee = aliceBalanceBefore - aliceBalanceAfter;
- expect(fee / UNIQUE < BigInt(Math.ceil(saneMaximumFee + createCollectionDeposit))).to.be.true;
- expect(fee / UNIQUE < BigInt(Math.ceil(saneMinimumFee + createCollectionDeposit))).to.be.true;
- });
+ expect(fee / unique < BigInt(Math.ceil(saneMaximumFee + createCollectionDeposit))).to.be.true;
+ expect(fee / unique < BigInt(Math.ceil(saneMinimumFee + createCollectionDeposit))).to.be.true;
});
- it('NFT Transfer fee is close to 0.1 Unique', async () => {
- await usingApi(async (api) => {
- await skipInflationBlock(api);
- await waitNewBlocks(api, 1);
+ itSub('NFT Transfer fee is close to 0.1 Unique', async ({helper}) => {
+ await skipInflationBlock(helper.api!);
+ await helper.wait.newBlocks(1);
- const collectionId = await createCollectionExpectSuccess();
- const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ });
+ // const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
+ const token = await collection.mintToken(alice, {Substrate: alice.address});
- const aliceBalanceBefore: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
- await transferExpectSuccess(collectionId, tokenId, alice, bob, 1, 'NFT');
- const aliceBalanceAfter: bigint = (await api.query.system.account(alice.address)).data.free.toBigInt();
+ const aliceBalanceBefore = await helper.balance.getSubstrate(alice.address);
+ await token.transfer(alice, {Substrate: bob.address});
+ const aliceBalanceAfter = await helper.balance.getSubstrate(alice.address);
- const fee = Number(aliceBalanceBefore - aliceBalanceAfter) / Number(UNIQUE);
- const expectedTransferFee = 0.1;
- // fee drifts because of NextFeeMultiplier
- const tolerance = 0.001;
+ const fee = Number(aliceBalanceBefore - aliceBalanceAfter) / Number(helper.balance.getOneTokenNominal());
+ const expectedTransferFee = 0.1;
+ // fee drifts because of NextFeeMultiplier
+ const tolerance = 0.001;
- expect(Math.abs(fee - expectedTransferFee)).to.be.lessThan(tolerance);
- });
+ expect(Math.abs(fee - expectedTransferFee)).to.be.lessThan(tolerance);
});
-
});
tests/src/destroyCollection.test.tsdiffbeforeafterboth--- a/tests/src/destroyCollection.test.ts
+++ b/tests/src/destroyCollection.test.ts
@@ -15,36 +15,44 @@
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
import {IKeyringPair} from '@polkadot/types/types';
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi} from './substrate/substrate-api';
-import {createCollectionExpectSuccess,
- destroyCollectionExpectSuccess,
- destroyCollectionExpectFailure,
- setCollectionLimitsExpectSuccess,
- addCollectionAdminExpectSuccess,
- getCreatedCollectionCount,
- createItemExpectSuccess,
- requirePallets,
- Pallets,
-} from './util/helpers';
+import {itSub, expect, usingPlaygrounds, Pallets} from './util/playgrounds';
-chai.use(chaiAsPromised);
-
describe('integration test: ext. destroyCollection():', () => {
- it('NFT collection can be destroyed', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await destroyCollectionExpectSuccess(collectionId);
- });
- it('Fungible collection can be destroyed', async () => {
- const collectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
- await destroyCollectionExpectSuccess(collectionId);
+ let alice: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice] = await helper.arrange.createAccounts([100n], donor);
+ });
});
- it('ReFungible collection can be destroyed', async function() {
- await requirePallets(this, [Pallets.ReFungible]);
- const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
- await destroyCollectionExpectSuccess(collectionId);
+ itSub('NFT collection can be destroyed', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ });
+ await collection.burn(alice);
+ expect(await collection.getData()).to.be.null;
+ });
+ itSub('Fungible collection can be destroyed', async ({helper}) => {
+ const collection = await helper.ft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ }, 0);
+ await collection.burn(alice);
+ expect(await collection.getData()).to.be.null;
+ });
+ itSub.ifWithPallets('ReFungible collection can be destroyed', [Pallets.ReFungible], async ({helper}) => {
+ const collection = await helper.rft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ });
+ await collection.burn(alice);
+ expect(await collection.getData()).to.be.null;
});
});
@@ -53,44 +61,60 @@
let bob: IKeyringPair;
before(async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- alice = privateKeyWrapper('//Alice');
- bob = privateKeyWrapper('//Bob');
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
});
});
- it('(!negative test!) Destroy a collection that never existed', async () => {
- await usingApi(async (api) => {
- // Find the collection that never existed
- const collectionId = await getCreatedCollectionCount(api) + 1;
- await destroyCollectionExpectFailure(collectionId);
+ itSub('(!negative test!) Destroy a collection that never existed', async ({helper}) => {
+ const collectionId = 1_000_000;
+ await expect(helper.collection.burn(alice, collectionId)).to.be.rejectedWith(/common\.CollectionNotFound/);
+ });
+ itSub('(!negative test!) Destroy a collection that has already been destroyed', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
});
- });
- it('(!negative test!) Destroy a collection that has already been destroyed', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await destroyCollectionExpectSuccess(collectionId);
- await destroyCollectionExpectFailure(collectionId);
+ await collection.burn(alice);
+ await expect(collection.burn(alice)).to.be.rejectedWith(/common\.CollectionNotFound/);
});
- it('(!negative test!) Destroy a collection using non-owner account', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await destroyCollectionExpectFailure(collectionId, '//Bob');
- await destroyCollectionExpectSuccess(collectionId, '//Alice');
+ itSub('(!negative test!) Destroy a collection using non-owner account', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ });
+ await expect(collection.burn(bob)).to.be.rejectedWith(/common\.NoPermission/);
});
- it('(!negative test!) Destroy a collection using collection admin account', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
- await destroyCollectionExpectFailure(collectionId, '//Bob');
+ itSub('(!negative test!) Destroy a collection using collection admin account', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ });
+ await collection.addAdmin(alice, {Substrate: bob.address});
+ await expect(collection.burn(bob)).to.be.rejectedWith(/common\.NoPermission/);
});
- it('fails when OwnerCanDestroy == false', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanDestroy: false});
-
- await destroyCollectionExpectFailure(collectionId, '//Alice');
+ itSub('fails when OwnerCanDestroy == false', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ limits: {
+ ownerCanDestroy: false,
+ },
+ });
+ await expect(collection.burn(alice)).to.be.rejectedWith(/common\.NoPermission/);
});
- it('fails when a collection still has a token', async () => {
- const collectionId = await createCollectionExpectSuccess();
- await createItemExpectSuccess(alice, collectionId, 'NFT');
-
- await destroyCollectionExpectFailure(collectionId, '//Alice');
+ itSub('fails when a collection still has a token', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ });
+ await collection.mintToken(alice, {Substrate: alice.address});
+ await expect(collection.burn(alice)).to.be.rejectedWith(/common\.CantDestroyNotEmptyCollection/);
});
});
tests/src/enableDisableTransfer.test.tsdiffbeforeafterboth--- a/tests/src/enableDisableTransfer.test.ts
+++ b/tests/src/enableDisableTransfer.test.ts
@@ -14,61 +14,69 @@
// You should have received a copy of the GNU General Public License
// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import usingApi from './substrate/substrate-api';
-import {
- createItemExpectSuccess,
- createCollectionExpectSuccess,
- transferExpectSuccess,
- transferExpectFailure,
- setTransferFlagExpectSuccess,
- setTransferFlagExpectFailure,
-} from './util/helpers';
-
-chai.use(chaiAsPromised);
+import {IKeyringPair} from '@polkadot/types/types';
+import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
describe('Enable/Disable Transfers', () => {
- it('User can transfer token with enabled transfer flag', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- // nft
- const nftCollectionId = await createCollectionExpectSuccess();
- const newNftTokenId = await createItemExpectSuccess(alice, nftCollectionId, 'NFT');
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
- // explicitely set transfer flag
- await setTransferFlagExpectSuccess(alice, nftCollectionId, true);
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
+ });
+ });
- await transferExpectSuccess(nftCollectionId, newNftTokenId, alice, bob, 1);
+ itSub('User can transfer token with enabled transfer flag', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ limits: {
+ transfersEnabled: true,
+ },
});
+ const token = await collection.mintToken(alice, {Substrate: alice.address});
+ await token.transfer(alice, {Substrate: bob.address});
+ expect(await token.getOwner()).to.be.deep.equal({Substrate: bob.address});
});
- it('User can\'n transfer token with disabled transfer flag', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const alice = privateKeyWrapper('//Alice');
- const bob = privateKeyWrapper('//Bob');
- // nft
- const nftCollectionId = await createCollectionExpectSuccess();
- const newNftTokenId = await createItemExpectSuccess(alice, nftCollectionId, 'NFT');
-
- // explicitely set transfer flag
- await setTransferFlagExpectSuccess(alice, nftCollectionId, false);
-
- await transferExpectFailure(nftCollectionId, newNftTokenId, alice, bob, 1);
+ itSub('User can\'n transfer token with disabled transfer flag', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ limits: {
+ transfersEnabled: false,
+ },
});
+ const token = await collection.mintToken(alice, {Substrate: alice.address});
+ await expect(token.transfer(alice, {Substrate: bob.address})).to.be.rejectedWith(/common\.TransferNotAllowed/);
});
});
describe('Negative Enable/Disable Transfers', () => {
- it('Non-owner cannot change transfer flag', async () => {
- await usingApi(async (api, privateKeyWrapper) => {
- const bob = privateKeyWrapper('//Bob');
- // nft
- const nftCollectionId = await createCollectionExpectSuccess();
+ let alice: IKeyringPair;
+ let bob: IKeyringPair;
+
+ before(async () => {
+ await usingPlaygrounds(async (helper, privateKey) => {
+ const donor = privateKey('//Alice');
+ [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
+ });
+ });
- // Change transfer flag
- await setTransferFlagExpectFailure(bob, nftCollectionId, false);
+ itSub('Non-owner cannot change transfer flag', async ({helper}) => {
+ const collection = await helper.nft.mintCollection(alice, {
+ name: 'test',
+ description: 'test',
+ tokenPrefix: 'test',
+ limits: {
+ transfersEnabled: true,
+ },
});
+
+ await expect(collection.setLimits(bob, {transfersEnabled: false})).to.be.rejectedWith(/common\.NoPermission/);
});
});
tests/src/nesting/properties.test.tsdiffbeforeafterboth--- a/tests/src/nesting/properties.test.ts
+++ b/tests/src/nesting/properties.test.ts
@@ -666,7 +666,6 @@
`on adding property #${i} by signer #${j}`,
).to.be.fulfilled;
}
-
}
const properties = await nestedToken.getProperties(propertyKeys);
tests/src/refungible.test.tsdiffbeforeafterboth--- a/tests/src/refungible.test.ts
+++ b/tests/src/refungible.test.ts
@@ -124,7 +124,7 @@
const token = await collection.mintToken(alice, 100n);
expect(await collection.isTokenExists(token.tokenId)).to.be.true;
expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
- expect((await token.burn(alice, 99n)).success).to.be.true;
+ expect(await token.burn(alice, 99n)).to.be.true;
expect(await collection.isTokenExists(token.tokenId)).to.be.true;
expect(await token.getBalance({Substrate: alice.address})).to.be.equal(1n);
});
@@ -136,7 +136,7 @@
expect(await collection.isTokenExists(token.tokenId)).to.be.true;
expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
- expect((await token.burn(alice, 100n)).success).to.be.true;
+ expect(await token.burn(alice, 100n)).to.be.true;
expect(await collection.isTokenExists(token.tokenId)).to.be.false;
});
@@ -152,17 +152,17 @@
expect(await token.getBalance({Substrate: alice.address})).to.be.equal(40n);
expect(await token.getBalance({Substrate: bob.address})).to.be.equal(60n);
- expect((await token.burn(alice, 40n)).success).to.be.true;
+ expect(await token.burn(alice, 40n)).to.be.true;
expect(await collection.isTokenExists(token.tokenId)).to.be.true;
expect(await token.getBalance({Substrate: alice.address})).to.be.equal(0n);
- expect((await token.burn(bob, 59n)).success).to.be.true;
+ expect(await token.burn(bob, 59n)).to.be.true;
expect(await token.getBalance({Substrate: bob.address})).to.be.equal(1n);
expect(await collection.isTokenExists(token.tokenId)).to.be.true;
- expect((await token.burn(bob, 1n)).success).to.be.true;
+ expect(await token.burn(bob, 1n)).to.be.true;
expect(await collection.isTokenExists(token.tokenId)).to.be.false;
});
tests/src/util/playgrounds/unique.tsdiffbeforeafterboth--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -141,7 +141,7 @@
return keyring.addFromUri(seed);
}
- static extractCollectionIdFromCreationResult(creationResult: ITransactionResult) {
+ static extractCollectionIdFromCreationResult(creationResult: ITransactionResult): number {
if (creationResult.status !== this.transactionStatus.SUCCESS) {
throw Error('Unable to create collection!');
}
@@ -160,12 +160,15 @@
return collectionId;
}
- static extractTokensFromCreationResult(creationResult: ITransactionResult) {
+ static extractTokensFromCreationResult(creationResult: ITransactionResult): {
+ success: boolean,
+ tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],
+ } {
if (creationResult.status !== this.transactionStatus.SUCCESS) {
throw Error('Unable to create tokens!');
}
let success = false;
- const tokens = [] as any;
+ const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];
creationResult.result.events.forEach(({event: {data, method, section}}) => {
if (method === 'ExtrinsicSuccess') {
success = true;
@@ -173,19 +176,23 @@
tokens.push({
collectionId: parseInt(data[0].toString(), 10),
tokenId: parseInt(data[1].toString(), 10),
- owner: data[2].toJSON(),
+ owner: data[2].toHuman(),
+ amount: data[3].toBigInt(),
});
}
});
return {success, tokens};
}
- static extractTokensFromBurnResult(burnResult: ITransactionResult) {
+ static extractTokensFromBurnResult(burnResult: ITransactionResult): {
+ success: boolean,
+ tokens: {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[],
+ } {
if (burnResult.status !== this.transactionStatus.SUCCESS) {
throw Error('Unable to burn tokens!');
}
let success = false;
- const tokens = [] as any;
+ const tokens = [] as {collectionId: number, tokenId: number, owner: CrossAccountId, amount: bigint}[];
burnResult.result.events.forEach(({event: {data, method, section}}) => {
if (method === 'ExtrinsicSuccess') {
success = true;
@@ -193,14 +200,15 @@
tokens.push({
collectionId: parseInt(data[0].toString(), 10),
tokenId: parseInt(data[1].toString(), 10),
- owner: data[2].toJSON(),
+ owner: data[2].toHuman(),
+ amount: data[3].toBigInt(),
});
}
});
return {success, tokens};
}
- static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string) {
+ static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string): boolean {
let eventId = null;
events.forEach(({event: {data, method, section}}) => {
if ((section === expectedSection) && (method === expectedMethod)) {
@@ -1022,12 +1030,9 @@
* @param tokenId ID of token
* @param amount amount of tokens to be burned. For NFT must be set to 1n
* @example burnToken(aliceKeyring, 10, 5);
- * @returns ```true``` and burnt token number is extrinsic success. Otherwise ```false``` and ```null```
+ * @returns ```true``` if the extrinsic is successful, otherwise ```false```
*/
- async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<{
- success: boolean,
- token: number | null
- }> {
+ async burnToken(signer: TSigner, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {
const burnResult = await this.helper.executeExtrinsic(
signer,
'api.tx.unique.burnItem', [collectionId, tokenId, amount],
@@ -1035,7 +1040,7 @@
);
const burnedTokens = this.helper.util.extractTokensFromBurnResult(burnResult);
if (burnedTokens.tokens.length > 1) throw Error('Burned multiple tokens');
- return {success: burnedTokens.success, token: burnedTokens.tokens.length > 0 ? burnedTokens.tokens[0] : null};
+ return burnedTokens.success;
}
/**
@@ -1161,7 +1166,9 @@
if (tokenData === null || tokenData.owner === null) return null;
const owner = {} as any;
for (const key of Object.keys(tokenData.owner)) {
- owner[key.toLocaleLowerCase()] = new CrossAccountId(tokenData.owner[key]).withNormalizedSubstrate();
+ owner[key.toLocaleLowerCase()] = key.toLocaleLowerCase() == 'substrate'
+ ? CrossAccountId.normalizeSubstrateAddress(tokenData.owner[key])
+ : tokenData.owner[key];
}
tokenData.normalizedOwner = CrossAccountId.fromLowerCaseKeys(owner);
return tokenData;
@@ -1711,9 +1718,9 @@
* @param tokenId ID of token
* @param amount number of pieces to be burnt
* @example burnToken(aliceKeyring, 10, 5);
- * @returns ```true``` and burnt token number, if extrinsic is successful. Otherwise ```false``` and ```null```
+ * @returns ```true``` if the extrinsic is successful, otherwise ```false```
*/
- async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<{ success: boolean; token: number | null; }> {
+ async burnToken(signer: IKeyringPair, collectionId: number, tokenId: number, amount=1n): Promise<boolean> {
return await super.burnToken(signer, collectionId, tokenId, amount);
}
@@ -1919,7 +1926,7 @@
* @returns ```true``` if extrinsic success, otherwise ```false```
*/
async burnTokens(signer: IKeyringPair, collectionId: number, amount=1n): Promise<boolean> {
- return (await super.burnToken(signer, collectionId, 0, amount)).success;
+ return await super.burnToken(signer, collectionId, 0, amount);
}
/**