git.delta.rocks / unique-network / refs/commits / 6360d02576ab

no syntactic changes

1RUST_TOOLCHAIN=nightly-2022-07-241RUST_TOOLCHAIN=nightly-2022-07-24
2POLKADOT_BUILD_BRANCH=release-v0.9.272POLKADOT_BUILD_BRANCH=release-v0.9.29
33
4POLKADOT_MAINNET_BRANCH=release-v0.9.264POLKADOT_MAINNET_BRANCH=release-v0.9.26
5UNIQUE_MAINNET_TAG=v9240105UNIQUE_MAINNET_TAG=v924010
13QUARTZ_REPLICA_FROM=wss://eu-ws-quartz.unique.network:44313QUARTZ_REPLICA_FROM=wss://eu-ws-quartz.unique.network:443
14UNIQUE_REPLICA_FROM=wss://eu-ws.unique.network:44314UNIQUE_REPLICA_FROM=wss://eu-ws.unique.network:443
1515
16POLKADOT_LAUNCH_BRANCH=feature/rewrite-chain-id-in-spec16POLKADOT_LAUNCH_BRANCH=unique-network
1717
18KARURA_BUILD_BRANCH=2.9.118KARURA_BUILD_BRANCH=2.9.1
19ACALA_BUILD_BRANCH=2.9.219ACALA_BUILD_BRANCH=2.9.2

125        run: docker pull uniquenetwork/builder-polkadot:${{ env.POLKADOT_BUILD_BRANCH }}           125        run: docker pull uniquenetwork/builder-polkadot:${{ env.POLKADOT_BUILD_BRANCH }}           
126126
127      - name: Build the stack127      - name: Build the stack
128        run: cd .docker/ && docker build --file ./Dockerfile-testnet.${{ matrix.network }}.yml --tag uniquenetwork/${{ matrix.network }}-testnet-local:nightly-${{ steps.branchname.outputs.value }}-${{ github.sha }} --tag uniquenetwork/${{ matrix.network }}-testnet-local:latest . 128        run: cd .docker/ && docker build --file ./Dockerfile-testnet.${{ matrix.network }}.yml --tag uniquenetwork/${{ matrix.network }}-testnet-local-nightly:nightly-${{ steps.branchname.outputs.value }}-${{ github.sha }} . 
129129
130      - name: Push docker version image130      - name: Push docker version image
131        run: docker push uniquenetwork/${{ matrix.network }}-testnet-local:nightly-${{ steps.branchname.outputs.value }}-${{ github.sha }}131        run: docker push uniquenetwork/${{ matrix.network }}-testnet-local-nightly:nightly-${{ steps.branchname.outputs.value }}-${{ github.sha }}
132
133      - name: Push docker latest image
134        run: docker push uniquenetwork/${{ matrix.network }}-testnet-local:latest
135132
136      - name: Clean Workspace133      - name: Clean Workspace
137        if: always()134        if: always()

19const config = {19const config = {
20  substrateUrl: process.env.substrateUrl || 'ws://127.0.0.1:9944',20  substrateUrl: process.env.substrateUrl || 'ws://127.0.0.1:9944',
21  frontierUrl: process.env.frontierUrl || 'http://127.0.0.1:9933',21  frontierUrl: process.env.frontierUrl || 'http://127.0.0.1:9933',
22  relayUrl: process.env.relayUrl || 'ws://127.0.0.1:9844',
23  acalaUrl: process.env.acalaUrl || 'ws://127.0.0.1:9946',
24  karuraUrl: process.env.acalaUrl || 'ws://127.0.0.1:9946',
25  moonbeamUrl: process.env.moonbeamUrl || 'ws://127.0.0.1:9947',
26  moonriverUrl: process.env.moonbeamUrl || 'ws://127.0.0.1:9947',
27  westmintUrl: process.env.westmintUrl || 'ws://127.0.0.1:9948',
22};28};
2329
24export default config;30export default config;

361  }361  }
362362
363  clearApi() {363  clearApi() {
364    super.clearApi();
364    this.web3 = null;365    this.web3 = null;
365  }366  }
366367

7  acceptNft,7  acceptNft,
8} from './util/tx';8} from './util/tx';
9import {NftIdTuple} from './util/fetch';9import {NftIdTuple} from './util/fetch';
10import {isNftChildOfAnother, expectTxFailure} from './util/helpers';10import {isNftChildOfAnother, expectTxFailure, requirePallets, Pallets} from './util/helpers';
11import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
1211
13describe('integration test: accept NFT', () => {12describe('integration test: accept NFT', () => {
14  let api: any;13  let api: any;
104    expect(isChild).to.be.false;103    expect(isChild).to.be.false;
105  });104  });
106105
107  after(() => { api.disconnect(); });106  after(async() => { await api.disconnect(); });
108});107});
109108

1import {expect} from 'chai';1import {expect} from 'chai';
2import {getApiConnection} from '../substrate/substrate-api';2import {getApiConnection} from '../substrate/substrate-api';
3import {NftIdTuple} from './util/fetch';3import {NftIdTuple} from './util/fetch';
4import {expectTxFailure, getResourceById} from './util/helpers';4import {expectTxFailure, getResourceById, requirePallets, Pallets} from './util/helpers';
5import {5import {
6  addNftBasicResource,6  addNftBasicResource,
7  acceptNftResource,7  acceptNftResource,
12  addNftComposableResource,12  addNftComposableResource,
13} from './util/tx';13} from './util/tx';
14import {RmrkTraitsResourceResourceInfo as ResourceInfo} from '@polkadot/types/lookup';14import {RmrkTraitsResourceResourceInfo as ResourceInfo} from '@polkadot/types/lookup';
15import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
1615
17describe('integration test: add NFT resource', () => {16describe('integration test: add NFT resource', () => {
18  const alice = '//Alice';17  const alice = '//Alice';
433432
434433
435  after(() => {434  after(() => {
436    api.disconnect();435    after(async() => { await api.disconnect(); });
437  });436  });
438});437});
439438

1import {expect} from 'chai';1import {expect} from 'chai';
2import {getApiConnection} from '../substrate/substrate-api';2import {getApiConnection} from '../substrate/substrate-api';
3import {createBase, addTheme} from './util/tx';3import {createBase, addTheme} from './util/tx';
4import {expectTxFailure} from './util/helpers';4import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
5import {getThemeNames} from './util/fetch';5import {getThemeNames} from './util/fetch';
6import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
76
8describe('integration test: add Theme to Base', () => {7describe('integration test: add Theme to Base', () => {
9  let api: any;8  let api: any;
126    await expectTxFailure(/rmrkEquip\.PermissionError/, tx);125    await expectTxFailure(/rmrkEquip\.PermissionError/, tx);
127  });126  });
128127
129  after(() => { api.disconnect(); });128  after(async() => { await api.disconnect(); });
130});129});
131130

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {expectTxFailure} from './util/helpers';2import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
3import {NftIdTuple, getChildren} from './util/fetch';3import {NftIdTuple, getChildren} from './util/fetch';
4import {burnNft, createCollection, sendNft, mintNft} from './util/tx';4import {burnNft, createCollection, sendNft, mintNft} from './util/tx';
55
6import chai from 'chai';6import chai from 'chai';
7import chaiAsPromised from 'chai-as-promised';7import chaiAsPromised from 'chai-as-promised';
8import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
98
10chai.use(chaiAsPromised);9chai.use(chaiAsPromised);
11const expect = chai.expect;10const expect = chai.expect;
167    });166    });
168  });167  });
169168
170  after(() => {169  after(async() => { await api.disconnect(); });
171    api.disconnect();
172  });
173});170});

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';2import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
3import {expectTxFailure} from './util/helpers';
4import {3import {
5  changeIssuer,4  changeIssuer,
6  createCollection,5  createCollection,
50    });49    });
51  });50  });
5251
53  after(() => {52  after(async() => { await api.disconnect(); });
54    api.disconnect();
55  });
56});53});

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';2import {requirePallets, Pallets} from './util/helpers';
3import {createCollection, createBase} from './util/tx';3import {createCollection, createBase} from './util/tx';
44
5describe('integration test: create new Base', () => {5describe('integration test: create new Base', () => {
84    ]);84    ]);
85  });85  });
8686
87  after(() => { api.disconnect(); });87  after(async() => { await api.disconnect(); });
88});88});
8989

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';2import {requirePallets, Pallets} from './util/helpers';
3import {createCollection} from './util/tx';3import {createCollection} from './util/tx';
44
5describe('Integration test: create new collection', () => {5describe('Integration test: create new collection', () => {
21    await createCollection(api, alice, 'no-limit-metadata', null, 'no-limit-symbol');21    await createCollection(api, alice, 'no-limit-metadata', null, 'no-limit-symbol');
22  });22  });
2323
24  after(() => { api.disconnect(); });24  after(async() => { await api.disconnect(); });
25});25});
2626

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';2import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
3import {expectTxFailure} from './util/helpers';
4import {createCollection, deleteCollection} from './util/tx';3import {createCollection, deleteCollection} from './util/tx';
54
6describe('integration test: delete collection', () => {5describe('integration test: delete collection', () => {
43    });42    });
44  });43  });
4544
46  after(() => {45  after(async() => { await api.disconnect(); });
47    api.disconnect();
48  });
49});46});

1import {ApiPromise} from '@polkadot/api';1import {ApiPromise} from '@polkadot/api';
2import {expect} from 'chai';2import {expect} from 'chai';
3import {getApiConnection} from '../substrate/substrate-api';3import {getApiConnection} from '../substrate/substrate-api';
4import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
5import {getNft, NftIdTuple} from './util/fetch';4import {getNft, NftIdTuple} from './util/fetch';
6import {expectTxFailure} from './util/helpers';5import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
7import {6import {
8  addNftComposableResource,7  addNftComposableResource,
9  addNftSlotResource,8  addNftSlotResource,
337    await expectTxFailure(/rmrkEquip\.CollectionNotEquippable/, tx);336    await expectTxFailure(/rmrkEquip\.CollectionNotEquippable/, tx);
338  });337  });
339338
340  after(() => {339  after(async() => { await api.disconnect(); });
341    api.disconnect();
342  });
343});340});

1import {expect} from 'chai';1import {expect} from 'chai';
2import {getApiConnection} from '../substrate/substrate-api';2import {getApiConnection} from '../substrate/substrate-api';
3import {requirePallets, Pallets} from '../deprecated-helpers/helpers';3import {requirePallets, Pallets} from './util/helpers';
4import {getOwnedNfts} from './util/fetch';4import {getOwnedNfts} from './util/fetch';
5import {mintNft, createCollection} from './util/tx';5import {mintNft, createCollection} from './util/tx';
66
76    });76    });
77  });77  });
7878
79  after(() => { api.disconnect(); });79  after(async() => { await api.disconnect(); });
80});80});
8181

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';2import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
3import {expectTxFailure} from './util/helpers';
4import {createCollection, lockCollection, mintNft} from './util/tx';3import {createCollection, lockCollection, mintNft} from './util/tx';
54
6describe('integration test: lock collection', () => {5describe('integration test: lock collection', () => {
113    });112    });
114  });113  });
115114
116  after(() => {115  after(async() => { await api.disconnect(); });
117    api.disconnect();
118  });
119});116});

1import {expect} from 'chai';1import {expect} from 'chai';
2import {getApiConnection} from '../substrate/substrate-api';2import {getApiConnection} from '../substrate/substrate-api';
3import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
4import {getNft} from './util/fetch';3import {getNft} from './util/fetch';
5import {expectTxFailure} from './util/helpers';4import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
6import {createCollection, mintNft} from './util/tx';5import {createCollection, mintNft} from './util/tx';
76
8describe('integration test: mint new NFT', () => {7describe('integration test: mint new NFT', () => {
208    expect(nft.isSome).to.be.false;207    expect(nft.isSome).to.be.false;
209  });208  });
210209
211  after(() => { api.disconnect(); });210  after(async() => { await api.disconnect(); });
212});211});
213212

7  rejectNft,7  rejectNft,
8} from './util/tx';8} from './util/tx';
9import {NftIdTuple} from './util/fetch';9import {NftIdTuple} from './util/fetch';
10import {isNftChildOfAnother, expectTxFailure} from './util/helpers';10import {isNftChildOfAnother, expectTxFailure, requirePallets, Pallets} from './util/helpers';
11import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
1211
13describe('integration test: reject NFT', () => {12describe('integration test: reject NFT', () => {
14  let api: any;13  let api: any;
91    await expectTxFailure(/rmrkCore\.CannotRejectNonPendingNft/, tx);90    await expectTxFailure(/rmrkCore\.CannotRejectNonPendingNft/, tx);
92  });91  });
9392
94  after(() => { api.disconnect(); });93  after(async() => { await api.disconnect(); });
95});94});
9695

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
3import {NftIdTuple} from './util/fetch';2import {NftIdTuple} from './util/fetch';
4import {expectTxFailure} from './util/helpers';3import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
5import {4import {
6  acceptResourceRemoval, addNftBasicResource, createCollection, mintNft, removeNftResource, sendNft,5  acceptResourceRemoval, addNftBasicResource, createCollection, mintNft, removeNftResource, sendNft,
7} from './util/tx';6} from './util/tx';
337    await expectTxFailure(/rmrkCore\.NoPermission/, tx);336    await expectTxFailure(/rmrkCore\.NoPermission/, tx);
338  });337  });
339338
340  after(() => {339  after(async() => { await api.disconnect(); });
341    api.disconnect();
342  });
343});340});

1import {expect} from 'chai';1import {executeTransaction} from '../substrate/substrate-api';
2import usingApi, {executeTransaction} from '../substrate/substrate-api';
3import {
4  createCollectionExpectSuccess,
5  createItemExpectSuccess,
6  getCreateCollectionResult,
7  getDetailedCollectionInfo,
8  getGenericResult,
9  requirePallets,
10  normalizeAccountId,
11  Pallets,
12} from '../deprecated-helpers/helpers';
13import {IKeyringPair} from '@polkadot/types/types';2import {IKeyringPair} from '@polkadot/types/types';
14import {ApiPromise} from '@polkadot/api';3import {itSub, expect, usingPlaygrounds, Pallets, requirePalletsOrSkip} from '../util';
15import {it} from 'mocha';4import {UniqueHelper} from '../util/playgrounds/unique';
165
17let alice: IKeyringPair;6let alice: IKeyringPair;
18let bob: IKeyringPair;7let bob: IKeyringPair;
198
20async function createRmrkCollection(api: ApiPromise, sender: IKeyringPair): Promise<{uniqueId: number, rmrkId: number}> {9async function createRmrkCollection(helper: UniqueHelper, sender: IKeyringPair): Promise<{uniqueId: number, rmrkId: number}> {
21  const tx = api.tx.rmrkCore.createCollection('metadata', null, 'symbol');10  const result = await helper.executeExtrinsic(sender, 'api.tx.rmrkCore.createCollection', ['metadata', null, 'symbol'], true);
22  const events = await executeTransaction(api, sender, tx);
2311
24  const uniqueResult = getCreateCollectionResult(events);12  const uniqueId = helper.util.extractCollectionIdFromCreationResult(result);
13
25  const rmrkResult = getGenericResult(events, 'rmrkCore', 'CollectionCreated', (data) => {14  let rmrkId = null;
15  result.result.events.forEach(({event: {data, method, section}}) => {
16    if ((section === 'rmrkCore') && (method === 'CollectionCreated')) {
26    return parseInt(data[1].toString(), 10);17      rmrkId = parseInt(data[1].toString(), 10);
18    }
27  });19  });
2820
21  if (rmrkId === null) {
22    throw Error('No rmrkCore.CollectionCreated event was found!');
23  }
24
29  return {25  return {
30    uniqueId: uniqueResult.collectionId,26    uniqueId,
31    rmrkId: rmrkResult.data!,27    rmrkId,
32  };28  };
33}29}
3430
35async function createRmrkNft(api: ApiPromise, sender: IKeyringPair, collectionId: number): Promise<number> {31async function createRmrkNft(helper: UniqueHelper, sender: IKeyringPair, collectionId: number): Promise<number> {
36  const tx = api.tx.rmrkCore.mintNft(32  const result = await helper.executeExtrinsic(
33    sender,
34    'api.tx.rmrkCore.mintNft',
37    sender.address,35    [
36      sender.address,
38    collectionId,37      collectionId,
39    sender.address,38      sender.address,
40    null,39      null,
41    'nft-metadata',40      'nft-metadata',
41      true,
42      null,
43    ],
42    true,44    true,
43    null,
44  );45  );
46
45  const events = await executeTransaction(api, sender, tx);47  let rmrkNftId = null;
48  result.result.events.forEach(({event: {data, method, section}}) => {
46  const result = getGenericResult(events, 'rmrkCore', 'NftMinted', (data) => {49    if ((section === 'rmrkCore') && (method === 'NftMinted')) {
47    return parseInt(data[2].toString(), 10);50      rmrkNftId = parseInt(data[2].toString(), 10);
51    }
48  });52  });
4953
50  return result.data!;54  if (rmrkNftId === null) {
55    throw Error('No rmrkCore.NftMinted event was found!');
51}56  }
5257
53async function isUnique(): Promise<boolean> {58  return rmrkNftId;
54  return usingApi(async api => {
55    const chain = await api.rpc.system.chain();
56
57    return chain.eq('UNIQUE');
58  });
59}59}
6060
61describe('RMRK External Integration Test', async () => {61describe('RMRK External Integration Test', async () => {
62  const itRmrk = (await isUnique() ? it : it.skip);
63
64  before(async function() {62  before(async function() {
65    await usingApi(async (api, privateKeyWrapper) => {63    await usingPlaygrounds(async (_helper, privateKey) => {
66      alice = privateKeyWrapper('//Alice');64      alice = await privateKey('//Alice');
67      await requirePallets(this, [Pallets.RmrkCore]);
68    });65    });
69  });66  });
7067
71  itRmrk('Creates a new RMRK collection that is mapped to a different ID and is tagged as external', async () => {68  itSub.ifWithPallets('Creates a new RMRK collection that is mapped to a different ID and is tagged as external', [Pallets.RmrkCore], async ({helper}) => {
72    await usingApi(async api => {69    // throw away collection to bump last Unique collection ID to test ID mapping
73      // throwaway collection to bump last Unique collection ID to test ID mapping
74      await createCollectionExpectSuccess();70    await helper.nft.mintCollection(alice, {tokenPrefix: 'unqt'});
7571
76      const collectionIds = await createRmrkCollection(api, alice);72    const collectionIds = await createRmrkCollection(helper, alice);
7773
78      expect(collectionIds.rmrkId).to.be.lessThan(collectionIds.uniqueId, 'collection ID mapping');74    expect(collectionIds.rmrkId).to.be.lessThan(collectionIds.uniqueId, 'collection ID mapping');
7975
80      const collection = (await getDetailedCollectionInfo(api, collectionIds.uniqueId))!;76    const collection = (await helper.nft.getCollectionObject(collectionIds.uniqueId).getData())!; // (await getDetailedCollectionInfo(api, collectionIds.uniqueId))!;
81      expect(collection.readOnly.toHuman(), 'tagged external').to.be.true;77    expect(collection.raw.readOnly, 'tagged external').to.be.true;
82    });
83  });78  });
84});79});
8580
86describe('Negative Integration Test: External Collections, Internal Ops', async () => {81describe('Negative Integration Test: External Collections, Internal Ops', async () => {
87  let uniqueCollectionId: number;82  let uniqueCollectionId: number;
88  let rmrkCollectionId: number;83  let rmrkCollectionId: number;
89  let rmrkNftId: number;84  let rmrkNftId: number;
85  let normalizedAlice: {Substrate: string};
9086
91  const itRmrk = (await isUnique() ? it : it.skip);87  before(async function() {
88    await usingPlaygrounds(async (helper, privateKey) => {
89      alice = await privateKey('//Alice');
90      bob = await privateKey('//Bob');
91      normalizedAlice = {Substrate: helper.address.normalizeSubstrateToChainFormat(alice.address)};
9292
93  before(async () => {93      requirePalletsOrSkip(this, helper, [Pallets.RmrkCore]);
94    await usingApi(async (api, privateKeyWrapper) => {
95      alice = privateKeyWrapper('//Alice');
96      bob = privateKeyWrapper('//Bob');
9794
98      const collectionIds = await createRmrkCollection(api, alice);95      const collectionIds = await createRmrkCollection(helper, alice);
99      uniqueCollectionId = collectionIds.uniqueId;96      uniqueCollectionId = collectionIds.uniqueId;
100      rmrkCollectionId = collectionIds.rmrkId;97      rmrkCollectionId = collectionIds.rmrkId;
10198
102      rmrkNftId = await createRmrkNft(api, alice, rmrkCollectionId);99      rmrkNftId = await createRmrkNft(helper, alice, rmrkCollectionId);
103    });100    });
104  });101  });
105102
106  itRmrk('[Negative] Forbids Unique operations with an external collection, handled by dispatch_call', async () => {103  itSub.ifWithPallets('[Negative] Forbids Unique operations with an external collection, handled by dispatch_call', [Pallets.RmrkCore], async ({helper}) => {
107    await usingApi(async api => {
108      // Collection item creation104    // Collection item creation
109105
110      const txCreateItem = api.tx.unique.createItem(uniqueCollectionId, normalizeAccountId(alice), 'NFT');106    await expect(helper.nft.mintToken(alice, {collectionId: uniqueCollectionId, owner: {Substrate: alice.address}}), 'creating item')
111      await expect(executeTransaction(api, alice, txCreateItem), 'creating item')
112        .to.be.rejectedWith(/common\.CollectionIsExternal/);107      .to.be.rejectedWith(/common\.CollectionIsExternal/);
113108
114      const txCreateMultipleItems = api.tx.unique.createMultipleItems(uniqueCollectionId, normalizeAccountId(alice), [{NFT: {}}, {NFT: {}}]);109    const txCreateMultipleItems = helper.getApi().tx.unique.createMultipleItems(uniqueCollectionId, normalizedAlice, [{NFT: {}}, {NFT: {}}]);
115      await expect(executeTransaction(api, alice, txCreateMultipleItems), 'creating multiple')110    await expect(executeTransaction(helper.getApi(), alice, txCreateMultipleItems), 'creating multiple')
116        .to.be.rejectedWith(/common\.CollectionIsExternal/);111      .to.be.rejectedWith(/common\.CollectionIsExternal/);
112  
113    await expect(helper.nft.mintMultipleTokens(alice, uniqueCollectionId, [{owner: {Substrate: alice.address}}]), 'creating multiple ex')
114      .to.be.rejectedWith(/common\.CollectionIsExternal/);
117115
118      const txCreateMultipleItemsEx = api.tx.unique.createMultipleItemsEx(uniqueCollectionId, {NFT: [{}]});116    // Collection properties
119      await expect(executeTransaction(api, alice, txCreateMultipleItemsEx), 'creating multiple ex')
120        .to.be.rejectedWith(/common\.CollectionIsExternal/);
121117
122      // Collection properties118    await expect(helper.nft.setProperties(alice, uniqueCollectionId, [{key: 'a', value: '1'}, {key: 'b'}]), 'setting collection properties')
119      .to.be.rejectedWith(/common\.CollectionIsExternal/);
123120
124      const txSetCollectionProperties = api.tx.unique.setCollectionProperties(uniqueCollectionId, [{key: 'a', value: '1'}, {key: 'b'}]);121    await expect(helper.nft.deleteProperties(alice, uniqueCollectionId, ['a']), 'deleting collection properties')
125      await expect(executeTransaction(api, alice, txSetCollectionProperties), 'setting collection properties')
126        .to.be.rejectedWith(/common\.CollectionIsExternal/);122      .to.be.rejectedWith(/common\.CollectionIsExternal/);
127123
128      const txDeleteCollectionProperties = api.tx.unique.deleteCollectionProperties(uniqueCollectionId, ['a']);124    await expect(helper.nft.setTokenPropertyPermissions(alice, uniqueCollectionId, [{key: 'a', permission: {mutable: true}}]), 'setting property permissions')
129      await expect(executeTransaction(api, alice, txDeleteCollectionProperties), 'deleting collection properties')
130        .to.be.rejectedWith(/common\.CollectionIsExternal/);125      .to.be.rejectedWith(/common\.CollectionIsExternal/);
131126
132      const txsetTokenPropertyPermissions = api.tx.unique.setTokenPropertyPermissions(uniqueCollectionId, [{key: 'a', permission: {mutable: true}}]);127    // NFT
133      await expect(executeTransaction(api, alice, txsetTokenPropertyPermissions), 'setting property permissions')
134        .to.be.rejectedWith(/common\.CollectionIsExternal/);
135128
136      // NFT129    await expect(helper.nft.burnToken(alice, uniqueCollectionId, rmrkNftId, 1n), 'burning')
130      .to.be.rejectedWith(/common\.CollectionIsExternal/);
137131
138      const txBurn = api.tx.unique.burnItem(uniqueCollectionId, rmrkNftId, 1);132    await expect(helper.nft.burnTokenFrom(alice, uniqueCollectionId, rmrkNftId, {Substrate: alice.address}, 1n), 'burning-from')
139      await expect(executeTransaction(api, alice, txBurn), 'burning').to.be.rejectedWith(/common\.CollectionIsExternal/);133      .to.be.rejectedWith(/common\.CollectionIsExternal/);
140134
141      const txBurnFrom = api.tx.unique.burnFrom(uniqueCollectionId, normalizeAccountId(alice), rmrkNftId, 1);135    await expect(helper.nft.transferToken(alice, uniqueCollectionId, rmrkNftId, {Substrate: bob.address}), 'transferring')
142      await expect(executeTransaction(api, alice, txBurnFrom), 'burning-from').to.be.rejectedWith(/common\.CollectionIsExternal/);136      .to.be.rejectedWith(/common\.CollectionIsExternal/);
143137
144      const txTransfer = api.tx.unique.transfer(normalizeAccountId(bob), uniqueCollectionId, rmrkNftId, 1);138    await expect(helper.nft.approveToken(alice, uniqueCollectionId, rmrkNftId, {Substrate: bob.address}), 'approving')
145      await expect(executeTransaction(api, alice, txTransfer), 'transferring').to.be.rejectedWith(/common\.CollectionIsExternal/);139      .to.be.rejectedWith(/common\.CollectionIsExternal/);
146140
147      const txApprove = api.tx.unique.approve(normalizeAccountId(bob), uniqueCollectionId, rmrkNftId, 1);141    await expect(helper.nft.transferTokenFrom(alice, uniqueCollectionId, rmrkNftId, {Substrate: alice.address}, {Substrate: bob.address}), 'transferring-from')
148      await expect(executeTransaction(api, alice, txApprove), 'approving').to.be.rejectedWith(/common\.CollectionIsExternal/);142      .to.be.rejectedWith(/common\.CollectionIsExternal/);
149143
150      const txTransferFrom = api.tx.unique.transferFrom(normalizeAccountId(alice), normalizeAccountId(bob), uniqueCollectionId, rmrkNftId, 1);144    // NFT properties
151      await expect(executeTransaction(api, alice, txTransferFrom), 'transferring-from').to.be.rejectedWith(/common\.CollectionIsExternal/);
152145
153      // NFT properties146    await expect(helper.nft.setTokenProperties(alice, uniqueCollectionId, rmrkNftId, [{key: 'a', value: '2'}]), 'setting token properties')
147      .to.be.rejectedWith(/common\.CollectionIsExternal/);
154148
155      const txSetTokenProperties = api.tx.unique.setTokenProperties(uniqueCollectionId, rmrkNftId, [{key: 'a', value: '2'}]);149    await expect(helper.nft.deleteTokenProperties(alice, uniqueCollectionId, rmrkNftId, ['a']))
156      await expect(executeTransaction(api, alice, txSetTokenProperties), 'setting token properties')
157        .to.be.rejectedWith(/common\.CollectionIsExternal/);
158
159      const txDeleteTokenProperties = api.tx.unique.deleteTokenProperties(uniqueCollectionId, rmrkNftId, ['a']);
160      await expect(executeTransaction(api, alice, txDeleteTokenProperties), 'deleting token properties')
161        .to.be.rejectedWith(/common\.CollectionIsExternal/);150      .to.be.rejectedWith(/common\.CollectionIsExternal/);
162    });
163  });151  });
164152
165  itRmrk('[Negative] Forbids Unique collection operations with an external collection', async () => {153  itSub.ifWithPallets('[Negative] Forbids Unique collection operations with an external collection', [Pallets.RmrkCore], async ({helper}) => {
166    await usingApi(async api => {154    await expect(helper.nft.burn(alice, uniqueCollectionId), 'destroying collection')
167      const txDestroyCollection = api.tx.unique.destroyCollection(uniqueCollectionId);
168      await expect(executeTransaction(api, alice, txDestroyCollection), 'destroying collection')
169        .to.be.rejectedWith(/common\.CollectionIsExternal/);155      .to.be.rejectedWith(/common\.CollectionIsExternal/);
170156
171      // Allow list157    // Allow list
172158
173      const txAddAllowList = api.tx.unique.addToAllowList(uniqueCollectionId, normalizeAccountId(bob));159    await expect(helper.nft.addToAllowList(alice, uniqueCollectionId, {Substrate: bob.address}), 'adding to allow list')
174      await expect(executeTransaction(api, alice, txAddAllowList), 'adding to allow list')
175        .to.be.rejectedWith(/common\.CollectionIsExternal/);160      .to.be.rejectedWith(/common\.CollectionIsExternal/);
176161
177      const txRemoveAllowList = api.tx.unique.removeFromAllowList(uniqueCollectionId, normalizeAccountId(bob));162    await expect(helper.nft.removeFromAllowList(alice, uniqueCollectionId, {Substrate: bob.address}), 'removing from allowlist')
178      await expect(executeTransaction(api, alice, txRemoveAllowList), 'removing from allowlist')
179        .to.be.rejectedWith(/common\.CollectionIsExternal/);163      .to.be.rejectedWith(/common\.CollectionIsExternal/);
180164
181      // Owner / Admin / Sponsor165    // Owner / Admin / Sponsor
182166
183      const txChangeOwner = api.tx.unique.changeCollectionOwner(uniqueCollectionId, bob.address);167    await expect(helper.nft.changeOwner(alice, uniqueCollectionId, bob.address), 'changing owner')
184      await expect(executeTransaction(api, alice, txChangeOwner), 'changing owner')
185        .to.be.rejectedWith(/common\.CollectionIsExternal/);168      .to.be.rejectedWith(/common\.CollectionIsExternal/);
186169
187      const txAddAdmin = api.tx.unique.addCollectionAdmin(uniqueCollectionId, normalizeAccountId(bob));170    await expect(helper.nft.addAdmin(alice, uniqueCollectionId, {Substrate: bob.address}), 'adding admin')
188      await expect(executeTransaction(api, alice, txAddAdmin), 'adding admin')
189        .to.be.rejectedWith(/common\.CollectionIsExternal/);171      .to.be.rejectedWith(/common\.CollectionIsExternal/);
190172
191      const txRemoveAdmin = api.tx.unique.removeCollectionAdmin(uniqueCollectionId, normalizeAccountId(bob));173    await expect(helper.nft.removeAdmin(alice, uniqueCollectionId, {Substrate: bob.address}), 'removing admin')
192      await expect(executeTransaction(api, alice, txRemoveAdmin), 'removing admin')
193        .to.be.rejectedWith(/common\.CollectionIsExternal/);174      .to.be.rejectedWith(/common\.CollectionIsExternal/);
194175
195      const txAddCollectionSponsor = api.tx.unique.setCollectionSponsor(uniqueCollectionId, bob.address);176    await expect(helper.nft.setSponsor(alice, uniqueCollectionId, bob.address), 'setting sponsor')
196      await expect(executeTransaction(api, alice, txAddCollectionSponsor), 'setting sponsor')
197        .to.be.rejectedWith(/common\.CollectionIsExternal/);177      .to.be.rejectedWith(/common\.CollectionIsExternal/);
198178
199      const txConfirmCollectionSponsor = api.tx.unique.confirmSponsorship(uniqueCollectionId);179    await expect(helper.nft.confirmSponsorship(alice, uniqueCollectionId), 'confirming sponsor')
200      await expect(executeTransaction(api, alice, txConfirmCollectionSponsor), 'confirming sponsor')
201        .to.be.rejectedWith(/common\.CollectionIsExternal/);180      .to.be.rejectedWith(/common\.CollectionIsExternal/);
202181
203      const txRemoveCollectionSponsor = api.tx.unique.removeCollectionSponsor(uniqueCollectionId);182    await expect(helper.nft.removeSponsor(alice, uniqueCollectionId), 'removing sponsor')
204      await expect(executeTransaction(api, alice, txRemoveCollectionSponsor), 'removing sponsor')
205        .to.be.rejectedWith(/common\.CollectionIsExternal/);183      .to.be.rejectedWith(/common\.CollectionIsExternal/);
206      184    
207      // Limits / permissions / transfers185    // Limits / permissions / transfers
208186
209      const txSetTransfers = api.tx.unique.setTransfersEnabledFlag(uniqueCollectionId, true);187    const txSetTransfers = helper.getApi().tx.unique.setTransfersEnabledFlag(uniqueCollectionId, true);
210      await expect(executeTransaction(api, alice, txSetTransfers), 'setting transfers enabled flag')188    await expect(executeTransaction(helper.getApi(), alice, txSetTransfers), 'setting transfers enabled flag')
211        .to.be.rejectedWith(/common\.CollectionIsExternal/);189      .to.be.rejectedWith(/common\.CollectionIsExternal/);
212190
213      const txSetLimits = api.tx.unique.setCollectionLimits(uniqueCollectionId, {transfersEnabled: false});191    await expect(helper.nft.setLimits(alice, uniqueCollectionId, {transfersEnabled: false}), 'setting collection limits')
214      await expect(executeTransaction(api, alice, txSetLimits), 'setting collection limits')
215        .to.be.rejectedWith(/common\.CollectionIsExternal/);192      .to.be.rejectedWith(/common\.CollectionIsExternal/);
216193
217      const txSetPermissions = api.tx.unique.setCollectionPermissions(uniqueCollectionId, {access: 'AllowList'});194    await expect(helper.nft.setPermissions(alice, uniqueCollectionId, {access: 'AllowList'}), 'setting collection permissions')
218      await expect(executeTransaction(api, alice, txSetPermissions), 'setting collection permissions')
219        .to.be.rejectedWith(/common\.CollectionIsExternal/);195      .to.be.rejectedWith(/common\.CollectionIsExternal/);
220    });
221  });196  });
222});197});
223198
224describe('Negative Integration Test: Internal Collections, External Ops', async () => {199describe('Negative Integration Test: Internal Collections, External Ops', async () => {
225  let collectionId: number;200  let collectionId: number;
226  let nftId: number;201  let nftId: number;
227202
228  const itRmrk = (await isUnique() ? it : it.skip);
229
230  before(async () => {203  before(async () => {
231    await usingApi(async (api, privateKeyWrapper) => {204    await usingPlaygrounds(async (helper, privateKey) => {
232      alice = privateKeyWrapper('//Alice');205      alice = await privateKey('//Alice');
233      bob = privateKeyWrapper('//Bob');206      bob = await privateKey('//Bob');
234207
235      collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});208      const collection = await helper.nft.mintCollection(alice, {tokenPrefix: 'iceo'});
236      nftId = await createItemExpectSuccess(alice, collectionId, 'NFT');209      collectionId = collection.collectionId;
210      nftId = (await collection.mintToken(alice)).tokenId;
237    });211    });
238  });212  });
239213
240  itRmrk('[Negative] Forbids RMRK operations with the internal collection and NFT (due to the lack of mapping)', async () => {214  itSub.ifWithPallets('[Negative] Forbids RMRK operations with the internal collection and NFT (due to the lack of mapping)', [Pallets.RmrkCore], async ({helper}) => {
241    await usingApi(async api => {215    const api = helper.getApi();
242      const txChangeOwner = api.tx.rmrkCore.changeCollectionIssuer(collectionId, bob.address);
243      await expect(executeTransaction(api, alice, txChangeOwner), 'changing collection issuer')
244        .to.be.rejectedWith(/rmrkCore\.CollectionUnknown/);
245216
246      const maxBurns = 10;217    const txChangeOwner = api.tx.rmrkCore.changeCollectionIssuer(collectionId, bob.address);
218    await expect(executeTransaction(api, alice, txChangeOwner), 'changing collection issuer')
219      .to.be.rejectedWith(/rmrkCore\.CollectionUnknown/);
220
221    const maxBurns = 10;
247      const txBurnItem = api.tx.rmrkCore.burnNft(collectionId, nftId, maxBurns);222    const txBurnItem = api.tx.rmrkCore.burnNft(collectionId, nftId, maxBurns);
248      await expect(executeTransaction(api, alice, txBurnItem), 'burning NFT').to.be.rejectedWith(/rmrkCore\.CollectionUnknown/);223    await expect(executeTransaction(api, alice, txBurnItem), 'burning NFT').to.be.rejectedWith(/rmrkCore\.CollectionUnknown/);
249    });
250  });224  });
251});225});
252226

2import {getApiConnection} from '../substrate/substrate-api';2import {getApiConnection} from '../substrate/substrate-api';
3import {createCollection, mintNft, sendNft} from './util/tx';3import {createCollection, mintNft, sendNft} from './util/tx';
4import {NftIdTuple} from './util/fetch';4import {NftIdTuple} from './util/fetch';
5import {isNftChildOfAnother, expectTxFailure} from './util/helpers';5import {isNftChildOfAnother, expectTxFailure, requirePallets, Pallets} from './util/helpers';
6import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
76
8describe('integration test: send NFT', () => {7describe('integration test: send NFT', () => {
9  let api: any;8  let api: any;
252    await expectTxFailure(/rmrkCore\.NoPermission/, tx);251    await expectTxFailure(/rmrkCore\.NoPermission/, tx);
253  });252  });
254253
255  after(() => { api.disconnect(); });254  after(async() => { await api.disconnect(); });
256});255});
257256

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';2import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
3import {expectTxFailure} from './util/helpers';
4import {createCollection, setPropertyCollection} from './util/tx';3import {createCollection, setPropertyCollection} from './util/tx';
54
6describe('integration test: set collection property', () => {5describe('integration test: set collection property', () => {
63    });62    });
64  });63  });
6564
66  after(() => {65  after(async() => { await api.disconnect(); });
67    api.disconnect();
68  });
69});66});

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';2import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
3import {expectTxFailure} from './util/helpers';
4import {createCollection, createBase, setEquippableList} from './util/tx';3import {createCollection, createBase, setEquippableList} from './util/tx';
54
6describe("integration test: set slot's Equippable List", () => {5describe("integration test: set slot's Equippable List", () => {
111    await expectTxFailure(/rmrkEquip\.PartDoesntExist/, tx);110    await expectTxFailure(/rmrkEquip\.PartDoesntExist/, tx);
112  });111  });
113112
114  after(() => { api.disconnect(); });113  after(async() => { await api.disconnect(); });
115});114});
116115

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';
3import {NftIdTuple} from './util/fetch';2import {NftIdTuple} from './util/fetch';
4import {expectTxFailure} from './util/helpers';3import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
5import {createCollection, mintNft, sendNft, setNftProperty} from './util/tx';4import {createCollection, mintNft, sendNft, setNftProperty} from './util/tx';
65
7describe('integration test: set NFT property', () => {6describe('integration test: set NFT property', () => {
85    await expectTxFailure(/rmrkCore\.NoPermission/, tx);84    await expectTxFailure(/rmrkCore\.NoPermission/, tx);
86  });85  });
8786
88  after(() => { api.disconnect(); });87  after(async() => { await api.disconnect(); });
89});88});
9089

1import {getApiConnection} from '../substrate/substrate-api';1import {getApiConnection} from '../substrate/substrate-api';
2import {requirePallets, Pallets} from '../deprecated-helpers/helpers';2import {expectTxFailure, requirePallets, Pallets} from './util/helpers';
3import {expectTxFailure} from './util/helpers';
4import {mintNft, createCollection, setResourcePriorities} from './util/tx';3import {mintNft, createCollection, setResourcePriorities} from './util/tx';
54
6describe('integration test: set NFT resource priorities', () => {5describe('integration test: set NFT resource priorities', () => {
53    await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx);52    await expectTxFailure(/rmrkCore\.NoAvailableNftId/, tx);
54  });53  });
5554
56  after(() => { api.disconnect(); });55  after(async() => { await api.disconnect(); });
57});56});
5857

10import {NftIdTuple, getChildren, getOwnedNfts, getCollectionProperties, getNftProperties, getResources} from './fetch';10import {NftIdTuple, getChildren, getOwnedNfts, getCollectionProperties, getNftProperties, getResources} from './fetch';
11import chaiAsPromised from 'chai-as-promised';11import chaiAsPromised from 'chai-as-promised';
12import chai from 'chai';12import chai from 'chai';
13import {getApiConnection} from '../../substrate/substrate-api';
14import {Context} from 'mocha';
1315
14chai.use(chaiAsPromised);16chai.use(chaiAsPromised);
15const expect = chai.expect;17const expect = chai.expect;
19    successData: T | null;21    successData: T | null;
20}22}
23
24export enum Pallets {
25  Inflation = 'inflation',
26  RmrkCore = 'rmrkcore',
27  RmrkEquip = 'rmrkequip',
28  ReFungible = 'refungible',
29  Fungible = 'fungible',
30  NFT = 'nonfungible',
31  Scheduler = 'scheduler',
32  AppPromotion = 'apppromotion',
33}
34
35let modulesNames: any;
36export function getModuleNames(api: ApiPromise): string[] {
37  if (typeof modulesNames === 'undefined')
38    modulesNames = api.runtimeMetadata.asLatest.pallets.map(m => m.name.toString().toLowerCase());
39  return modulesNames;
40}
41
42export async function missingRequiredPallets(requiredPallets: string[]): Promise<string[]> {
43  const api = await getApiConnection();
44  const pallets = getModuleNames(api);
45  await api.disconnect();
46
47  return requiredPallets.filter(p => !pallets.includes(p));
48}
49
50export async function requirePallets(mocha: Context, requiredPallets: string[]) {
51  const missingPallets = await missingRequiredPallets(requiredPallets);
52
53  if (missingPallets.length > 0) {
54    const skippingTestMsg = `\tSkipping test "${mocha.test?.title}".`;
55    const missingPalletsMsg = `\tThe following pallets are missing:\n\t- ${missingPallets.join('\n\t- ')}`;
56    const skipMsg = `${skippingTestMsg}\n${missingPalletsMsg}`;
57
58    console.error('\x1b[38:5:208m%s\x1b[0m', skipMsg);
59
60    mocha.skip();
61  }
62}
2163
22export function makeNftOwner(api: ApiPromise, owner: string | NftIdTuple): NftOwner {64export function makeNftOwner(api: ApiPromise, owner: string | NftIdTuple): NftOwner {
23  const isNftSending = (typeof owner !== 'string');65  const isNftSending = (typeof owner !== 'string');