git.delta.rocks / unique-network / refs/commits / 4e76702c569f

3// file 'LICENSE', which is part of this source code package.3// file 'LICENSE', which is part of this source code package.
4//4//
55
6import chai from "chai";6import chai from 'chai';
7import chaiAsPromised from 'chai-as-promised';7import chaiAsPromised from 'chai-as-promised';
8import usingApi, { submitTransactionAsync, submitTransactionExpectFailAsync } from "./substrate/substrate-api";8import usingApi, { submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
9import privateKey from "./substrate/privateKey";9import privateKey from './substrate/privateKey';
10import {10import {
11  deployFlipper11  deployFlipper,
12} from "./util/contracthelpers";12} from './util/contracthelpers';
13import {13import {
14  getGenericResult, normalizeAccountId14  getGenericResult,
15} from "./util/helpers"15} from './util/helpers';
1616
17chai.use(chaiAsPromised);17chai.use(chaiAsPromised);
18const expect = chai.expect;18const expect = chai.expect;
1919
20describe('Integration Test addToContractWhiteList', () => {20describe('Integration Test addToContractWhiteList', () => {
2121
22  it(`Add an address to a contract white list`, async () => {22  it('Add an address to a contract white list', async () => {
23    await usingApi(async api => {23    await usingApi(async api => {
24      const bob = privateKey("//Bob");24      const bob = privateKey('//Bob');
25      const [contract, deployer] = await deployFlipper(api);25      const [contract, deployer] = await deployFlipper(api);
2626
27      const whiteListedBefore = (await api.query.nft.contractWhiteList(contract.address, bob.address)).toJSON();27      const whiteListedBefore = (await api.query.nft.contractWhiteList(contract.address, bob.address)).toJSON();
35    });35    });
36  });36  });
3737
38  it(`Adding same address to white list repeatedly should not produce errors`, async () => {38  it('Adding same address to white list repeatedly should not produce errors', async () => {
39    await usingApi(async api => {39    await usingApi(async api => {
40      const bob = privateKey("//Bob");40      const bob = privateKey('//Bob');
41      const [contract, deployer] = await deployFlipper(api);41      const [contract, deployer] = await deployFlipper(api);
4242
43      const whiteListedBefore = (await api.query.nft.contractWhiteList(contract.address, bob.address)).toJSON();43      const whiteListedBefore = (await api.query.nft.contractWhiteList(contract.address, bob.address)).toJSON();
5858
59describe('Negative Integration Test addToContractWhiteList', () => {59describe('Negative Integration Test addToContractWhiteList', () => {
6060
61  it(`Add an address to a white list of a non-contract`, async () => {61  it('Add an address to a white list of a non-contract', async () => {
62    await usingApi(async api => {62    await usingApi(async api => {
63      const alice = privateKey("//Bob");63      const alice = privateKey('//Bob');
64      const bob = privateKey("//Bob");64      const bob = privateKey('//Bob');
65      const charlieGuineaPig = privateKey("//Charlie");65      const charlieGuineaPig = privateKey('//Charlie');
6666
67      const whiteListedBefore = (await api.query.nft.contractWhiteList(charlieGuineaPig.address, bob.address)).toJSON();67      const whiteListedBefore = (await api.query.nft.contractWhiteList(charlieGuineaPig.address, bob.address)).toJSON();
68      const addTx = api.tx.nft.addToContractWhiteList(charlieGuineaPig.address, bob.address);68      const addTx = api.tx.nft.addToContractWhiteList(charlieGuineaPig.address, bob.address);
74    });74    });
75  });75  });
7676
77  it(`Add to a contract white list using a non-owner address`, async () => {77  it('Add to a contract white list using a non-owner address', async () => {
78    await usingApi(async api => {78    await usingApi(async api => {
79      const bob = privateKey("//Bob");79      const bob = privateKey('//Bob');
80      const [contract, deployer] = await deployFlipper(api);80      const [contract] = await deployFlipper(api);
8181
82      const whiteListedBefore = (await api.query.nft.contractWhiteList(contract.address, bob.address)).toJSON();82      const whiteListedBefore = (await api.query.nft.contractWhiteList(contract.address, bob.address)).toJSON();
83      const addTx = api.tx.nft.addToContractWhiteList(contract.address, bob.address);83      const addTx = api.tx.nft.addToContractWhiteList(contract.address, bob.address);

27describe('Integration Test ext. addToWhiteList()', () => {
27describe('Integration Test ext. addToWhiteList()', () => {
28
28
29  before(async () => {
29  before(async () => {
30    await usingApi(async (api) => {
30    await usingApi(async () => {
31      Alice = privateKey('//Alice');
31      Alice = privateKey('//Alice');
32      Bob = privateKey('//Bob');
32      Bob = privateKey('//Bob');
33    });
33    });

82  let Charlie: IKeyringPair;82  let Charlie: IKeyringPair;
8383
84  before(async () => {84  before(async () => {
85    await usingApi(async (api) => {85    await usingApi(async () => {
86      Alice = privateKey('//Alice');86      Alice = privateKey('//Alice');
87      Bob = privateKey('//Bob');87      Bob = privateKey('//Bob');
88      Charlie = privateKey('//Charlie');88      Charlie = privateKey('//Charlie');

3// file 'LICENSE', which is part of this source code package.3// file 'LICENSE', which is part of this source code package.
4//4//
55
6import usingApi from "./substrate/substrate-api";6import usingApi from './substrate/substrate-api';
7import { expect } from "chai";7import { expect } from 'chai';
8import { ApiPromise } from "@polkadot/api";8import { ApiPromise } from '@polkadot/api';
99
10const BlockTimeMs = 12000;10const BlockTimeMs = 12000;
11const ToleranceMs = 1000;11const ToleranceMs = 1000;
1212
13/* eslint no-async-promise-executor: "off" */
13async function getBlocks(api: ApiPromise): Promise<number[]> {14function getBlocks(api: ApiPromise): Promise<number[]> {
14  return new Promise<number[]>(async (resolve, reject) => {15  return new Promise<number[]>(async (resolve, reject) => {
15    const blockNumbers: number[] = [];16    const blockNumbers: number[] = [];
16    setTimeout(() => reject('Block production test failed due to timeout.'), BlockTimeMs + ToleranceMs);17    setTimeout(() => reject('Block production test failed due to timeout.'), BlockTimeMs + ToleranceMs);
27describe('Block Production smoke test', () => {28describe('Block Production smoke test', () => {
28  it('Node produces new blocks', async () => {29  it('Node produces new blocks', async () => {
29    await usingApi(async (api) => {30    await usingApi(async (api) => {
30      let blocks: number[] | undefined = await getBlocks(api);31      const blocks: number[] | undefined = await getBlocks(api);
31      expect(blocks[0]).to.be.lessThan(blocks[1]);32      expect(blocks[0]).to.be.lessThan(blocks[1]);
32    });33    });
33  });34  });

4//4//
55
6import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';6import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
7import { Keyring } from "@polkadot/api";7import { Keyring } from '@polkadot/api';
8import { IKeyringPair } from "@polkadot/types/types";8import { IKeyringPair } from '@polkadot/types/types';
9import { 9import { 
10  createCollectionExpectSuccess, 10  createCollectionExpectSuccess, 
11  createItemExpectSuccess,11  createItemExpectSuccess,
12  getGenericResult,12  getGenericResult,
13  destroyCollectionExpectSuccess,13  destroyCollectionExpectSuccess,
14  normalizeAccountId14  normalizeAccountId,
15} from './util/helpers';15} from './util/helpers';
16import { nullPublicKey } from "./accounts";
1716
18import chai from 'chai';17import chai from 'chai';
19import chaiAsPromised from 'chai-as-promised';18import chaiAsPromised from 'chai-as-promised';
2524
26describe('integration test: ext. burnItem():', () => {25describe('integration test: ext. burnItem():', () => {
27  before(async () => {26  before(async () => {
28    await usingApi(async (api) => {27    await usingApi(async () => {
29      const keyring = new Keyring({ type: 'sr25519' });28      const keyring = new Keyring({ type: 'sr25519' });
30      alice = keyring.addFromUri(`//Alice`);29      alice = keyring.addFromUri('//Alice');
31      bob = keyring.addFromUri(`//Bob`);30      bob = keyring.addFromUri('//Bob');
32    });31    });
33  });32  });
3433
139138
140describe('Negative integration test: ext. burnItem():', () => {139describe('Negative integration test: ext. burnItem():', () => {
141  before(async () => {140  before(async () => {
142    await usingApi(async (api) => {141    await usingApi(async () => {
143      const keyring = new Keyring({ type: 'sr25519' });142      const keyring = new Keyring({ type: 'sr25519' });
144      alice = keyring.addFromUri(`//Alice`);143      alice = keyring.addFromUri('//Alice');
145      bob = keyring.addFromUri(`//Bob`);144      bob = keyring.addFromUri('//Bob');
146    });145    });
147  });146  });
148147

6import chai from 'chai';6import chai from 'chai';
7import chaiAsPromised from 'chai-as-promised';7import chaiAsPromised from 'chai-as-promised';
8import privateKey from './substrate/privateKey';8import privateKey from './substrate/privateKey';
9import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from "./substrate/substrate-api";9import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
10import { createCollectionExpectSuccess, createCollectionExpectFailure, normalizeAccountId } from "./util/helpers";10import { createCollectionExpectSuccess, normalizeAccountId } from './util/helpers';
1111
12chai.use(chaiAsPromised);12chai.use(chaiAsPromised);
13const expect = chai.expect;13const expect = chai.expect;
32});32});
3333
34describe('Negative Integration Test changeCollectionOwner(collection_id, new_owner):', () => {34describe('Negative Integration Test changeCollectionOwner(collection_id, new_owner):', () => {
35  it(`Not owner can't change owner.`, async () => {35  it('Not owner can\'t change owner.', async () => {
36    await usingApi(async api => {36    await usingApi(async api => {
37      const collectionId = await createCollectionExpectSuccess();37      const collectionId = await createCollectionExpectSuccess();
38      const alice = privateKey('//Alice');38      const alice = privateKey('//Alice');
48      await createCollectionExpectSuccess();48      await createCollectionExpectSuccess();
49    });49    });
50  });50  });
51  it(`Can't change owner of not existing collection.`, async () => {51  it('Can\'t change owner of not existing collection.', async () => {
52    await usingApi(async api => {52    await usingApi(async api => {
53      const collectionId = (1<<32) - 1;53      const collectionId = (1<<32) - 1;
54      const alice = privateKey('//Alice');54      const alice = privateKey('//Alice');

10import chaiAsPromised from 'chai-as-promised';10import chaiAsPromised from 'chai-as-promised';
11import privateKey from '../substrate/privateKey';11import privateKey from '../substrate/privateKey';
12import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';12import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';
13import { createCollectionExpectSuccess, createItemExpectSuccess, nftEventMessage } from '../util/helpers';13import { createCollectionExpectSuccess, nftEventMessage } from '../util/helpers';
1414
15chai.use(chaiAsPromised);15chai.use(chaiAsPromised);
16const expect = chai.expect;16const expect = chai.expect;

10import chaiAsPromised from 'chai-as-promised';10import chaiAsPromised from 'chai-as-promised';
11import privateKey from '../substrate/privateKey';11import privateKey from '../substrate/privateKey';
12import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';12import usingApi, {submitTransactionAsync} from '../substrate/substrate-api';
13import { createCollectionExpectSuccess, createItemExpectSuccess, nftEventMessage } from '../util/helpers';13import { createCollectionExpectSuccess, nftEventMessage } from '../util/helpers';
1414
15chai.use(chaiAsPromised);15chai.use(chaiAsPromised);
16const expect = chai.expect;16const expect = chai.expect;

1import { IKeyringPair } from '@polkadot/types/types';
1import { IKeyringPair } from '@polkadot/types/types';
2import chai from 'chai';
2import chai from 'chai';
3import chaiAsPromised from 'chai-as-promised';
3import chaiAsPromised from 'chai-as-promised';
4import { alicesPublicKey, bobsPublicKey } from '../accounts';
5import getBalance from '../substrate/get-balance';
6import privateKey from '../substrate/privateKey';
4import privateKey from '../substrate/privateKey';
7import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
5import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
8import waitNewBlocks from '../substrate/wait-new-blocks';
9import {
6import {
10  createCollectionExpectSuccess,
7  createCollectionExpectSuccess,
11  createItemExpectSuccess,
8  createItemExpectSuccess,
12  setCollectionSponsorExpectSuccess,
13} from '../util/helpers';
9} from '../util/helpers';
14
10
15chai.use(chaiAsPromised);
11chai.use(chaiAsPromised);

1import { IKeyringPair } from '@polkadot/types/types';
1import { IKeyringPair } from '@polkadot/types/types';
2import chai from 'chai';
2import chai from 'chai';
3import chaiAsPromised from 'chai-as-promised';
3import chaiAsPromised from 'chai-as-promised';
4import { alicesPublicKey, bobsPublicKey } from '../accounts';
5import getBalance from '../substrate/get-balance';
6import privateKey from '../substrate/privateKey';
4import privateKey from '../substrate/privateKey';
7import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
5import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
8import waitNewBlocks from '../substrate/wait-new-blocks';
9import {
6import {
10  createCollectionExpectSuccess,
7  createCollectionExpectSuccess,
11  createItemExpectSuccess,
8  createItemExpectSuccess,
12  setCollectionSponsorExpectSuccess,
13} from '../util/helpers';
9} from '../util/helpers';
14
10
15chai.use(chaiAsPromised);
11chai.use(chaiAsPromised);
16const expect = chai.expect;
12const expect = chai.expect;
17let Alice: IKeyringPair;
13let Alice: IKeyringPair;
18let Bob: IKeyringPair;
14let Bob: IKeyringPair;
19let Ferdie: IKeyringPair;
15
20
21before(async () => {
16before(async () => {
22  await usingApi(async () => {
17  await usingApi(async () => {
23    Alice = privateKey('//Alice');
18    Alice = privateKey('//Alice');
24    Bob = privateKey('//Bob');
19    Bob = privateKey('//Bob');
25    Ferdie = privateKey('//Ferdie');
26  });
20  });
27});
21});
28
22

1import { IKeyringPair } from '@polkadot/types/types';
1import { IKeyringPair } from '@polkadot/types/types';
2import chai from 'chai';
2import chai from 'chai';
3import chaiAsPromised from 'chai-as-promised';
3import chaiAsPromised from 'chai-as-promised';
4import { alicesPublicKey, bobsPublicKey } from '../accounts';
5import getBalance from '../substrate/get-balance';
6import privateKey from '../substrate/privateKey';
4import privateKey from '../substrate/privateKey';
7import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
5import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
8import waitNewBlocks from '../substrate/wait-new-blocks';
9import {
6import {
10  createCollectionExpectSuccess,
7  createCollectionExpectSuccess,
11  createItemExpectSuccess,
8  createItemExpectSuccess,
12  setCollectionSponsorExpectSuccess,
13} from '../util/helpers';
9} from '../util/helpers';
14
10
15chai.use(chaiAsPromised);
11chai.use(chaiAsPromised);
44        burnItem.signAndSend(Alice),
39        burnItem.signAndSend(Alice),
45      ]);
40      ]);
46      await timeoutPromise(10000);
41      await timeoutPromise(10000);
47      let itemBurn: boolean = false;
42      let itemBurn = false;
48      itemBurn = (await (api.query.nft.nftItemList(collectionId, itemId))).toJSON() as boolean;
43      itemBurn = (await (api.query.nft.nftItemList(collectionId, itemId))).toJSON() as boolean;
49      // tslint:disable-next-line: no-unused-expression
44      // tslint:disable-next-line: no-unused-expression
50      expect(itemBurn).to.be.null;
45      expect(itemBurn).to.be.null;

1import { IKeyringPair } from '@polkadot/types/types';1import { IKeyringPair } from '@polkadot/types/types';
2import BN from 'bn.js';
3import chai from 'chai';2import chai from 'chai';
4import chaiAsPromised from 'chai-as-promised';3import chaiAsPromised from 'chai-as-promised';
5import privateKey from '../substrate/privateKey';4import privateKey from '../substrate/privateKey';
6import usingApi, { submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';5import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
7import {6import {
8  createCollectionExpectSuccess,7  createCollectionExpectSuccess,
9} from '../util/helpers';8} from '../util/helpers';
109
11chai.use(chaiAsPromised);10chai.use(chaiAsPromised);
12const expect = chai.expect;11const expect = chai.expect;
13interface ITokenDataType {
14  Owner: number[];
15  ConstData: number[];
16  VariableData: number[];
17}
18let Alice: IKeyringPair;12let Alice: IKeyringPair;
19let Bob: IKeyringPair;13let Bob: IKeyringPair;
20let Ferdie: IKeyringPair;14let Ferdie: IKeyringPair;
21let Charlie: IKeyringPair;
22let Eve: IKeyringPair;
23let Dave: IKeyringPair;
2415
25before(async () => {16before(async () => {
26  await usingApi(async () => {17  await usingApi(async () => {
27    Alice = privateKey('//Alice');18    Alice = privateKey('//Alice');
28    Bob = privateKey('//Bob');19    Bob = privateKey('//Bob');
29    Ferdie = privateKey('//Ferdie');20    Ferdie = privateKey('//Ferdie');
30    Charlie = privateKey('//Charlie');
31    Eve = privateKey('//Eve');
32    Dave = privateKey('//Dave');
33  });21  });
34});22});
3523
51        destroyCollection.signAndSend(Alice),38        destroyCollection.signAndSend(Alice),
52      ]);39      ]);
53      await timeoutPromise(10000);40      await timeoutPromise(10000);
54      let whiteList: boolean = false;41      let whiteList = false;
55      whiteList = (await api.query.nft.whiteList(collectionId, Ferdie.address)).toJSON() as boolean;42      whiteList = (await api.query.nft.whiteList(collectionId, Ferdie.address)).toJSON() as boolean;
56      // tslint:disable-next-line: no-unused-expression43      // tslint:disable-next-line: no-unused-expression
57      expect(whiteList).to.be.false;44      expect(whiteList).to.be.false;

1010
11chai.use(chaiAsPromised);11chai.use(chaiAsPromised);
12const expect = chai.expect;12const expect = chai.expect;
13interface ITokenDataType {
14  Owner: number[];
15  ConstData: number[];
16  VariableData: number[];
17}
18let Alice: IKeyringPair;13let Alice: IKeyringPair;
19let Bob: IKeyringPair;14let Bob: IKeyringPair;
20let Ferdie: IKeyringPair;15let Ferdie: IKeyringPair;
51      await submitTransactionAsync(Alice, changeAdminTx3);46      await submitTransactionAsync(Alice, changeAdminTx3);
5247
53      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));48      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));
54      //
55      const addAdmOne = api.tx.nft.addCollectionAdmin(collectionId, Ferdie.address);49      const addAdmOne = api.tx.nft.addCollectionAdmin(collectionId, Ferdie.address);
56      const addAdmTwo = api.tx.nft.addCollectionAdmin(collectionId, Charlie.address);50      const addAdmTwo = api.tx.nft.addCollectionAdmin(collectionId, Charlie.address);
57      await Promise.all51      await Promise.all([

3import chai from 'chai';3import chai from 'chai';
4import chaiAsPromised from 'chai-as-promised';4import chaiAsPromised from 'chai-as-promised';
5import privateKey from '../substrate/privateKey';5import privateKey from '../substrate/privateKey';
6import usingApi, { submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';6import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
7import {7import {
8  createCollectionExpectSuccess,8  createCollectionExpectSuccess,
9} from '../util/helpers';9} from '../util/helpers';
1010
11chai.use(chaiAsPromised);11chai.use(chaiAsPromised);
12const expect = chai.expect;12const expect = chai.expect;
13interface ITokenDataType {
14  Owner: number[];
15  ConstData: number[];
16  VariableData: number[];
17}
18let Alice: IKeyringPair;13let Alice: IKeyringPair;
19let Bob: IKeyringPair;14let Bob: IKeyringPair;
20let Ferdie: IKeyringPair;
21let Charlie: IKeyringPair;
22let Eve: IKeyringPair;
23let Dave: IKeyringPair;
2415
25before(async () => {16before(async () => {
26  await usingApi(async () => {17  await usingApi(async () => {
27    Alice = privateKey('//Alice');18    Alice = privateKey('//Alice');
28    Bob = privateKey('//Bob');19    Bob = privateKey('//Bob');
29    Ferdie = privateKey('//Ferdie');
30    Charlie = privateKey('//Charlie');
31    Eve = privateKey('//Eve');
32    Dave = privateKey('//Dave');
33  });20  });
34});21});
3522
42      await submitTransactionAsync(Alice, changeAdminTx);29      await submitTransactionAsync(Alice, changeAdminTx);
43      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));30      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));
44      await timeoutPromise(10000);31      await timeoutPromise(10000);
45      //
46      const args = [{ nft: ['0x31', '0x31'] }, { nft: ['0x32', '0x32'] }, { nft: ['0x33', '0x33'] }];32      const args = [{ nft: ['0x31', '0x31'] }, { nft: ['0x32', '0x32'] }, { nft: ['0x33', '0x33'] }];
47      const addItemAdm = api.tx.nft.createMultipleItems(collectionId, Bob.address, args);33      const addItemAdm = api.tx.nft.createMultipleItems(collectionId, Bob.address, args);
48      const removeAdm = api.tx.nft.removeCollectionAdmin(collectionId, Bob.address);34      const removeAdm = api.tx.nft.removeCollectionAdmin(collectionId, Bob.address);

1import { IKeyringPair } from '@polkadot/types/types';1import { IKeyringPair } from '@polkadot/types/types';
2import BN from 'bn.js';
3import chai from 'chai';2import chai from 'chai';
4import chaiAsPromised from 'chai-as-promised';3import chaiAsPromised from 'chai-as-promised';
5import privateKey from '../substrate/privateKey';4import privateKey from '../substrate/privateKey';
6import usingApi, { submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';5import usingApi from '../substrate/substrate-api';
7import {6import {
8  createCollectionExpectSuccess, createItemExpectSuccess, setCollectionSponsorExpectSuccess,7  createCollectionExpectSuccess, setCollectionSponsorExpectSuccess,
9} from '../util/helpers';8} from '../util/helpers';
109
11chai.use(chaiAsPromised);10chai.use(chaiAsPromised);
12const expect = chai.expect;11const expect = chai.expect;
13interface ITokenDataType {
14  Owner: number[];
15  ConstData: number[];
16  VariableData: number[];
17}
18let Alice: IKeyringPair;12let Alice: IKeyringPair;
19let Bob: IKeyringPair;13let Bob: IKeyringPair;
20let Ferdie: IKeyringPair;14let Ferdie: IKeyringPair;
35      await setCollectionSponsorExpectSuccess(collectionId, Bob.address);29      await setCollectionSponsorExpectSuccess(collectionId, Bob.address);
36      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));30      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));
37      await timeoutPromise(10000);31      await timeoutPromise(10000);
38      //
39      const confirmSponsorship = api.tx.nft.confirmSponsorship(collectionId);32      const confirmSponsorship = api.tx.nft.confirmSponsorship(collectionId);
40      const changeCollectionOwner = api.tx.nft.changeCollectionOwner(collectionId, Ferdie.address);33      const changeCollectionOwner = api.tx.nft.changeCollectionOwner(collectionId, Ferdie.address);
41      await Promise.all34      await Promise.all([

5import getBalance from '../substrate/get-balance';
5import getBalance from '../substrate/get-balance';
6import privateKey from '../substrate/privateKey';
6import privateKey from '../substrate/privateKey';
7import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
7import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
8import waitNewBlocks from '../substrate/wait-new-blocks';
9import {
8import {
10  confirmSponsorshipExpectSuccess,
9  confirmSponsorshipExpectSuccess,
11  createCollectionExpectSuccess,
10  createCollectionExpectSuccess,
17const expect = chai.expect;
16const expect = chai.expect;
18let Alice: IKeyringPair;
17let Alice: IKeyringPair;
19let Bob: IKeyringPair;
18let Bob: IKeyringPair;
20let Ferdie: IKeyringPair;
19
21
22before(async () => {
20before(async () => {
23  await usingApi(async () => {
21  await usingApi(async () => {
24    Alice = privateKey('//Alice');
22    Alice = privateKey('//Alice');
25    Bob = privateKey('//Bob');
23    Bob = privateKey('//Bob');
26    Ferdie = privateKey('//Ferdie');
27  });
24  });
28});
25});
29
26
38      const itemId = await createItemExpectSuccess(Bob, collectionId, 'NFT');
35      const itemId = await createItemExpectSuccess(Bob, collectionId, 'NFT');
39      await setCollectionSponsorExpectSuccess(collectionId, Bob.address);
36      await setCollectionSponsorExpectSuccess(collectionId, Bob.address);
40      await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
37      await confirmSponsorshipExpectSuccess(collectionId, '//Bob');
41      //
38
42      const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);
39      const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);
43      const sendItem = api.tx.nft.transfer(Alice.address, collectionId, itemId, 1);
40      const sendItem = api.tx.nft.transfer(Alice.address, collectionId, itemId, 1);
44      const revokeSponsor = api.tx.nft.removeCollectionSponsor(collectionId);
41      const revokeSponsor = api.tx.nft.removeCollectionSponsor(collectionId);

1313
14chai.use(chaiAsPromised);14chai.use(chaiAsPromised);
15const expect = chai.expect;15const expect = chai.expect;
16interface ITokenDataType {
17  Owner: number[];
18  ConstData: number[];
19  VariableData: number[];
20}
21let Alice: IKeyringPair;16let Alice: IKeyringPair;
22let Bob: IKeyringPair;17let Bob: IKeyringPair;
23let Ferdie: IKeyringPair;18let Ferdie: IKeyringPair;
63      expect(subTxTesult.success).to.be.true;58      expect(subTxTesult.success).to.be.true;
64      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));59      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));
65      await timeoutPromise(10000);60      await timeoutPromise(10000);
66      //61
67      const args = [{ nft: ['0x31', '0x31'] }, { nft: ['0x32', '0x32'] }, { nft: ['0x33', '0x33'] }];62      const args = [{ nft: ['0x31', '0x31'] }, { nft: ['0x32', '0x32'] }, { nft: ['0x33', '0x33'] }];
68      const mintItemOne = api.tx.nft63      const mintItemOne = api.tx.nft
69        .createMultipleItems(collectionId, Ferdie.address, args);64        .createMultipleItems(collectionId, Ferdie.address, args);

2import chai from 'chai';
2import chai from 'chai';
3import chaiAsPromised from 'chai-as-promised';
3import chaiAsPromised from 'chai-as-promised';
4import privateKey from '../substrate/privateKey';
4import privateKey from '../substrate/privateKey';
5import usingApi, { submitTransactionAsync } from '../substrate/substrate-api';
5import usingApi from '../substrate/substrate-api';
6import waitNewBlocks from '../substrate/wait-new-blocks';
7import {
6import {
8  addToWhiteListExpectSuccess,
7  addToWhiteListExpectSuccess,
9  createCollectionExpectSuccess,
8  createCollectionExpectSuccess,
13chai.use(chaiAsPromised);
12chai.use(chaiAsPromised);
14const expect = chai.expect;
13const expect = chai.expect;
15let Alice: IKeyringPair;
14let Alice: IKeyringPair;
16let Bob: IKeyringPair;
17let Ferdie: IKeyringPair;
15let Ferdie: IKeyringPair;
18
16
19before(async () => {
17before(async () => {
20  await usingApi(async () => {
18  await usingApi(async () => {
21    Alice = privateKey('//Alice');
19    Alice = privateKey('//Alice');
22    Bob = privateKey('//Bob');
23    Ferdie = privateKey('//Ferdie');
20    Ferdie = privateKey('//Ferdie');
24  });
21  });
25});
22});
32      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));
29      const timeoutPromise = (timeout: number) => new Promise((resolve) => setTimeout(resolve, timeout));
33      await setMintPermissionExpectSuccess(Alice, collectionId, true);
30      await setMintPermissionExpectSuccess(Alice, collectionId, true);
34      await addToWhiteListExpectSuccess(Alice, collectionId, Ferdie.address);
31      await addToWhiteListExpectSuccess(Alice, collectionId, Ferdie.address);
35      //
32
36      const mintItem = api.tx.nft.createItem(collectionId, Ferdie.address, 'NFT');
33      const mintItem = api.tx.nft.createItem(collectionId, Ferdie.address, 'NFT');
37      const offMinting = api.tx.nft.setMintPermission(collectionId, false);
34      const offMinting = api.tx.nft.setMintPermission(collectionId, false);
38      await Promise.all
35      await Promise.all([
39      ([
40        mintItem.signAndSend(Ferdie),
36        mintItem.signAndSend(Ferdie),
41        offMinting.signAndSend(Alice),
37        offMinting.signAndSend(Alice),
42      ]);
38      ]);
43      let itemList: boolean = false;
39      let itemList = false;
44      itemList = (await (api.query.nft.nftItemList(collectionId, mintItem))).toJSON() as boolean;
40      itemList = (await (api.query.nft.nftItemList(collectionId, mintItem))).toJSON() as boolean;
45      // tslint:disable-next-line: no-unused-expression
41      // tslint:disable-next-line: no-unused-expression
46      expect(itemList).to.be.null;
42      expect(itemList).to.be.null;