git.delta.rocks / unique-network / refs/commits / 3ed96161dde6

difftreelog

approve and transferFrom test scenarios

kpozdnikin2021-01-15parent: #c980d88.patch.diff
in: master

6 files changed

modifiedtests/package.jsondiffbeforeafterboth
--- a/tests/package.json
+++ b/tests/package.json
@@ -21,7 +21,10 @@
     "testSetSchemaVersion": "mocha --timeout 9999999 -r ts-node/register ./**/setSchemaVersion.test.ts",
     "testSetCollectionLimits": "mocha --timeout 9999999 -r ts-node/register ./**/setCollectionLimits.test.ts",
     "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",
-    "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts"
+    "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
+    "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts",
+    "testTransferFrom": "mocha --timeout 9999999 -r ts-node/register ./**/transferFrom.test.ts",
+    "testCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts"
   },
   "author": "",
   "license": "Apache 2.0",
modifiedtests/src/approve.test.tsdiffbeforeafterboth
--- a/tests/src/approve.test.ts
+++ b/tests/src/approve.test.ts
@@ -8,53 +8,151 @@
 import chaiAsPromised from 'chai-as-promised';
 import privateKey from './substrate/privateKey';
 import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
-import {createCollectionExpectSuccess, destroyCollectionExpectSuccess} from './util/helpers';
+import {
+  approveExpectFail,
+  approveExpectSuccess,
+  createCollectionExpectSuccess,
+  createItemExpectSuccess,
+  destroyCollectionExpectSuccess,
+} from './util/helpers';
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
-interface ITokenDataType {
-  Owner: number[];
-  ConstData: number[];
-  VariableData: number[];
-}
-
 describe('Integration Test approve(spender, collection_id, item_id, amount):', () => {
   it('Execute the extrinsic and check approvedList', async () => {
     await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const nftCollectionId = await createCollectionExpectSuccess();
+      // nft
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
+      // reFungible
+      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
 
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
+
+  it('Remove approval by using 0 amount', async () => {
+    await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const nftCollectionId = await createCollectionExpectSuccess();
+      // nft
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1);
+      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 0);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1);
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 0);
+      // reFungible
+      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 1);
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 0);
+
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
+    });
+  });
 });
 
 describe('Negative Integration Test approve(spender, collection_id, item_id, amount):', () => {
   it('Approve for a collection that does not exist', async () => {
     await usingApi(async (api: ApiPromise) => {
-
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      await approveExpectFail(nftCollectionId + 1, 1, Alice, Bob);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      await approveExpectFail(fungibleCollectionId + 1, 1, Alice, Bob);
+      // reFungible
+      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      await approveExpectFail(reFungibleCollectionId + 1, 1, Alice, Bob);
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
 
   it('Approve for a collection that was destroyed', async () => {
     await usingApi(async (api: ApiPromise) => {
-
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await approveExpectFail(nftCollectionId, 1, Alice, Bob);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await approveExpectFail(fungibleCollectionId, 1, Alice, Bob);
+      // reFungible
+      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
+      await approveExpectFail(reFungibleCollectionId, 1, Alice, Bob);
     });
   });
 
   it('Approve transfer of a token that does not exist', async () => {
     await usingApi(async (api: ApiPromise) => {
-
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      // nft
+      const nftCollectionId = await createCollectionExpectSuccess();
+      await approveExpectFail(nftCollectionId, 2, Alice, Bob);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      await approveExpectFail(fungibleCollectionId, 2, Alice, Bob);
+      // reFungible
+      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      await approveExpectFail(reFungibleCollectionId, 2, Alice, Bob);
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
 
   it('Approve using the address that does not own the approved token', async () => {
     await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const nftCollectionId = await createCollectionExpectSuccess();
+      // nft
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await approveExpectFail(nftCollectionId, newNftTokenId, Bob, Alice);
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice);
+      // reFungible
+      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Bob, Alice);
 
-    });
-  });
-
-  it('Remove approval by using 0 amount', async () => {
-    await usingApi(async (api: ApiPromise) => {
-
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      await destroyCollectionExpectSuccess(fungibleCollectionId);
+      await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
 });
modifiedtests/src/createCollection.test.tsdiffbeforeafterboth
--- a/tests/src/createCollection.test.ts
+++ b/tests/src/createCollection.test.ts
@@ -5,15 +5,15 @@
 
 import chai from 'chai';
 import chaiAsPromised from 'chai-as-promised';
-import { default as usingApi } from "./substrate/substrate-api";
-import { createCollectionExpectSuccess, createCollectionExpectFailure, CollectionMode } from "./util/helpers";
+import { default as usingApi } from './substrate/substrate-api';
+import { createCollectionExpectFailure, createCollectionExpectSuccess } from './util/helpers';
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
 describe('integration test: ext. createCollection():', () => {
   it('Create new NFT collection', async () => {
-    await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: 'NFT'});
+    await createCollectionExpectSuccess({name: 'A', description: 'B', tokenPrefix: 'C', mode: {type: 'NFT'}});
   });
   it('Create new NFT collection whith collection_name of maximum length (64 bytes)', async () => {
     await createCollectionExpectSuccess({name: 'A'.repeat(64)});
@@ -25,34 +25,33 @@
     await createCollectionExpectSuccess({tokenPrefix: 'A'.repeat(16)});
   });
   it('Create new Fungible collection', async () => {
-    await createCollectionExpectSuccess({mode: 'Fungible'});
+    await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
   });
   it('Create new ReFungible collection', async () => {
-    await createCollectionExpectSuccess({mode: 'ReFungible'});
+    await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
   });
 });
 
 describe('(!negative test!) integration test: ext. createCollection():', () => {
   it('(!negative test!) create new NFT collection whith incorrect data (mode)', async () => {
     await usingApi(async (api) => {
-      const AcollectionCount = parseInt((await api.query.nft.collectionCount()).toString());
+      const AcollectionCount = parseInt((await api.query.nft.collectionCount()).toString(), 10);
 
-      const badTransaction = async function () { 
-        await createCollectionExpectSuccess({mode: 'BadMode' as CollectionMode});
-      };
+      const badTransaction = async () => await createCollectionExpectSuccess({mode: {type: 'Invalid'}});
+      // tslint:disable-next-line:no-unused-expression
       expect(badTransaction()).to.be.rejected;
 
-      const BcollectionCount = parseInt((await api.query.nft.collectionCount()).toString());
+      const BcollectionCount = parseInt((await api.query.nft.collectionCount()).toString(), 10);
       expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Incorrect collection created.');
     });
   });
   it('(!negative test!) create new NFT collection whith incorrect data (collection_name)', async () => {
-    await createCollectionExpectFailure({name: 'A'.repeat(65)});
+    await createCollectionExpectFailure({ name: 'A'.repeat(65), mode: {type: 'NFT'}});
   });
   it('(!negative test!) create new NFT collection whith incorrect data (collection_description)', async () => {
-    await createCollectionExpectFailure({description: 'A'.repeat(257)});
+    await createCollectionExpectFailure({ description: 'A'.repeat(257), mode: { type: 'NFT' }});
   });
   it('(!negative test!) create new NFT collection whith incorrect data (token_prefix)', async () => {
-    await createCollectionExpectFailure({tokenPrefix: 'A'.repeat(17)});
+    await createCollectionExpectFailure({tokenPrefix: 'A'.repeat(17), mode: {type: 'NFT'}});
   });
 });
modifiedtests/src/substrate/substrate-api.tsdiffbeforeafterboth
--- a/tests/src/substrate/substrate-api.ts
+++ b/tests/src/substrate/substrate-api.ts
@@ -90,7 +90,6 @@
         res(rec);
         console.error = consoleError;
         console.log = consoleLog;
-        
       });
     };
     const reject = (errror: any) => {
@@ -104,6 +103,8 @@
       await transaction.signAndSend(sender, ({ events = [], status }) => {
         const transactionStatus = getTransactionStatus(events, status);
 
+        console.log('transactionStatus', transactionStatus, 'events', events);
+
         if (transactionStatus == TransactionStatus.Success) {
           resolve(events);
         } else if (transactionStatus == TransactionStatus.Fail) {
@@ -114,4 +115,4 @@
       reject(e);
     }
   });
-}
\ No newline at end of file
+}
modifiedtests/src/transferFrom.test.tsdiffbeforeafterboth
--- a/tests/src/transferFrom.test.ts
+++ b/tests/src/transferFrom.test.ts
@@ -8,21 +8,47 @@
 import chaiAsPromised from 'chai-as-promised';
 import privateKey from './substrate/privateKey';
 import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
-import {createCollectionExpectSuccess, destroyCollectionExpectSuccess} from './util/helpers';
+import {
+  approveExpectSuccess,
+  createCollectionExpectSuccess,
+  createItemExpectSuccess,
+  destroyCollectionExpectSuccess,
+  transferFromExpectSuccess,
+} from './util/helpers';
+import {IKeyringPair} from "@polkadot/types/types";
 
 chai.use(chaiAsPromised);
 const expect = chai.expect;
 
-interface ITokenDataType {
-  Owner: number[];
-  ConstData: number[];
-  VariableData: number[];
-}
-
 describe('Integration Test transferFrom(from, recipient, collection_id, item_id, value):', () => {
-  it('Execute the extrinsic and check nftItemList - owner of toren', async () => {
+  it('Execute the extrinsic and check nftItemList - owner of token', async () => {
     await usingApi(async (api: ApiPromise) => {
+      const Alice = privateKey('//Alice');
+      const Bob = privateKey('//Bob');
+      const Charlie = privateKey('//CHARLIE');
+      const nftCollectionId = await createCollectionExpectSuccess();
+      console.log('nftCollectionId', nftCollectionId);
+      const collectionInfo = await api.query.nft.collection(nftCollectionId);
+      console.log('collectionInfo', collectionInfo);
+      // nft
+      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
+      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
 
+      await transferFromExpectSuccess(nftCollectionId, newNftTokenId, Alice, Charlie, 1, 'NFT');
+
+      // fungible
+      /*const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
+      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
+      // reFungible
+      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
+      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
+      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);*/
+
+      // garbage collection :-D
+      await destroyCollectionExpectSuccess(nftCollectionId);
+      // await destroyCollectionExpectSuccess(fungibleCollectionId);
+      // await destroyCollectionExpectSuccess(reFungibleCollectionId);
     });
   });
 });
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
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 { ApiPromise, Keyring } from '@polkadot/api';
7import chaiAsPromised from 'chai-as-promised';7import { Enum, Struct } from '@polkadot/types/codec';
8import type { AccountId, EventRecord } from '@polkadot/types/interfaces';8import type { AccountId, EventRecord } from '@polkadot/types/interfaces';
9import { ApiPromise, Keyring } from "@polkadot/api";9import { u128 } from '@polkadot/types/primitive';
10import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from "../substrate/substrate-api";10import { IKeyringPair } from '@polkadot/types/types';
11import privateKey from '../substrate/privateKey';11import { BigNumber } from 'bignumber.js';
12import { alicesPublicKey, nullPublicKey } from "../accounts";12import BN from 'bn.js';
13import { strToUTF16, utf16ToStr, hexToStr } from './util';13import chai from 'chai';
14import { IKeyringPair } from '@polkadot/types/types';14import chaiAsPromised from 'chai-as-promised';
15import { BigNumber } from 'bignumber.js';15import { alicesPublicKey, nullPublicKey } from '../accounts';
16import { Struct, Enum } from '@polkadot/types/codec';16import privateKey from '../substrate/privateKey';
17import { u128 } from '@polkadot/types/primitive';17import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';
18import { ICollectionInterface } from '../types';18import { ICollectionInterface } from '../types';
19import BN from "bn.js";19import { hexToStr, strToUTF16, utf16ToStr } from './util';
2020
21chai.use(chaiAsPromised);21chai.use(chaiAsPromised);
22const expect = chai.expect;22const expect = chai.expect;
25  success: boolean,25  success: boolean,
26};26};
2727
28type CreateCollectionResult = {28interface CreateCollectionResult {
29  success: boolean,29  success: boolean;
30  collectionId: number30  collectionId: number;
31};31}
3232
33type CreateItemResult = {33interface CreateItemResult {
34  success: boolean,34  success: boolean;
35  collectionId: number,35  collectionId: number;
36  itemId: number36  itemId: number;
37};37}
38
39interface ITokenDataType {
40  Owner: number[];
41  ConstData: number[];
42  VariableData: number[];
43}
3844
39export function getGenericResult(events: EventRecord[]): GenericResult {45export function getGenericResult(events: EventRecord[]): GenericResult {
40  let result: GenericResult = {46  const result: GenericResult = {
41    success: false47    success: false,
42  }48  };
43  events.forEach(({ phase, event: { data, method, section } }) => {49  events.forEach(({ phase, event: { data, method, section } }) => {
44    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);50    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);
45    if (method == 'ExtrinsicSuccess') {51    if (method === 'ExtrinsicSuccess') {
46      result.success = true;52      result.success = true;
47    }53    }
48  });54  });
60      collectionId = parseInt(data[0].toString());66      collectionId = parseInt(data[0].toString());
61    }67    }
62  });68  });
63  let result: CreateCollectionResult = {69  const result: CreateCollectionResult = {
64    success,70    success,
65    collectionId71    collectionId,
66  }72  };
67  return result;73  return result;
68}74}
6975
80      itemId = parseInt(data[1].toString());86      itemId = parseInt(data[1].toString());
81    }87    }
82  });88  });
83  let result: CreateItemResult = {89  const result: CreateItemResult = {
84    success,90    success,
85    collectionId,91    collectionId,
86    itemId92    itemId,
87  }93  };
88  return result;94  return result;
89}95}
96
97interface Invalid {
98  type: 'Invalid';
99}
100
101interface Nft {
102  type: 'NFT';
103}
104
105interface Fungible {
106  type: 'Fungible';
107  decimalPoints: number;
108}
109
110interface ReFungible {
111  type: 'ReFungible';
112  decimalPoints: number;
113}
90114
91export type CollectionMode = 'NFT' | 'Fungible' | 'ReFungible';115type CollectionMode = Nft | Fungible | ReFungible | Invalid;
116
92export type CreateCollectionParams = {117export type CreateCollectionParams = {
93  mode: CollectionMode,118  mode: CollectionMode,
94  name: string,119  name: string,
95  description: string,120  description: string,
96  tokenPrefix: string121  tokenPrefix: string,
97};122};
98123
99const defaultCreateCollectionParams: CreateCollectionParams = {124const defaultCreateCollectionParams: CreateCollectionParams = {
100  name: 'name',
101  description: 'description',125  description: 'description',
102  mode: 'NFT',126  mode: { type: 'NFT' },
127  name: 'name',
103  tokenPrefix: 'prefix'128  tokenPrefix: 'prefix',
104}129}
105130
106export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {131export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {
109  let collectionId: number = 0;134  let collectionId: number = 0;
110  await usingApi(async (api) => {135  await usingApi(async (api) => {
111    // Get number of collections before the transaction136    // Get number of collections before the transaction
112    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());137    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);
113138
114    // Run the CreateCollection transaction139    // Run the CreateCollection transaction
115    const alicePrivateKey = privateKey('//Alice');140    const alicePrivateKey = privateKey('//Alice');
141
142    let modeprm = {};
143    if (mode.type === 'NFT') {
144      modeprm = {nft: null};
145    } else if (mode.type === 'Fungible') {
146      modeprm = {fungible: mode.decimalPoints};
147    } else if (mode.type === 'ReFungible') {
148      modeprm = {refungible: mode.decimalPoints};
149    } else if (mode.type === 'Invalid') {
150      modeprm = {invalid: null};
151    }
152
116    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), mode);153    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);
117    const events = await submitTransactionAsync(alicePrivateKey, tx);154    const events = await submitTransactionAsync(alicePrivateKey, tx);
118    const result = getCreateCollectionResult(events);155    const result = getCreateCollectionResult(events);
119156
120    // Get number of collections after the transaction157    // Get number of collections after the transaction
121    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());158    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);
122159
123    // Get the collection 160    // Get the collection
124    const collection: any = (await api.query.nft.collection(result.collectionId)).toJSON();161    const collection: any = (await api.query.nft.collection(result.collectionId)).toJSON();
125162
126    // What to expect163    // What to expect
164    // tslint:disable-next-line:no-unused-expression
127    expect(result.success).to.be.true;165    expect(result.success).to.be.true;
128    expect(result.collectionId).to.be.equal(BcollectionCount);166    expect(result.collectionId).to.be.equal(BcollectionCount);
167    // tslint:disable-next-line:no-unused-expression
129    expect(collection).to.be.not.null;168    expect(collection).to.be.not.null;
130    expect(BcollectionCount).to.be.equal(AcollectionCount+1, 'Error: NFT collection NOT created.');169    expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');
131    expect(collection.Owner).to.be.equal(alicesPublicKey);170    expect(collection.Owner).to.be.equal(alicesPublicKey);
142export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {181export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {
143  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};182  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};
183
184  let modeprm = {};
185  if (mode.type === 'NFT') {
186    modeprm = {nft: null};
187  } else if (mode.type === 'Fungible') {
188    modeprm = {fungible: mode.decimalPoints};
189  } else if (mode.type === 'ReFungible') {
190    modeprm = {refungible: mode.decimalPoints};
191  } else if (mode.type === 'Invalid') {
192    modeprm = {invalid: null};
193  }
144194
145  await usingApi(async (api) => {195  await usingApi(async (api) => {
146    // Get number of collections before the transaction196    // Get number of collections before the transaction
147    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());197    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());
148198
149    // Run the CreateCollection transaction199    // Run the CreateCollection transaction
150    const alicePrivateKey = privateKey('//Alice');200    const alicePrivateKey = privateKey('//Alice');
151    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), mode);201    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);
152    const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;202    const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;
153    const result = getCreateCollectionResult(events);203    const result = getCreateCollectionResult(events);
154204
155    // Get number of collections after the transaction205    // Get number of collections after the transaction
156    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());206    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());
157207
158    // What to expect208    // What to expect
209    // tslint:disable-next-line:no-unused-expression
159    expect(result.success).to.be.false;210    expect(result.success).to.be.false;
160    expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');211    expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');
161  });212  });
201    const events = await submitTransactionAsync(alicePrivateKey, tx);252    const events = await submitTransactionAsync(alicePrivateKey, tx);
202    const result = getDestroyResult(events);253    const result = getDestroyResult(events);
203254
204    // Get the collection 255    // Get the collection
205    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();256    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
206257
207    // What to expect258    // What to expect
220    const events = await submitTransactionAsync(alicePrivateKey, tx);271    const events = await submitTransactionAsync(alicePrivateKey, tx);
221    const result = getGenericResult(events);272    const result = getGenericResult(events);
222273
223    // Get the collection 274    // Get the collection
224    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();275    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
225276
226    // What to expect277    // What to expect
239    const events = await submitTransactionAsync(alicePrivateKey, tx);290    const events = await submitTransactionAsync(alicePrivateKey, tx);
240    const result = getGenericResult(events);291    const result = getGenericResult(events);
241292
242    // Get the collection 293    // Get the collection
243    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();294    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
244295
245    // What to expect296    // What to expect
278    const events = await submitTransactionAsync(sender, tx);329    const events = await submitTransactionAsync(sender, tx);
279    const result = getGenericResult(events);330    const result = getGenericResult(events);
280331
281    // Get the collection 332    // Get the collection
282    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();333    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
283334
284    // What to expect335    // What to expect
300351
301export interface CreateFungibleData extends Struct {352export interface CreateFungibleData extends Struct {
302  readonly value: u128;353  readonly value: u128;
303};354}
304355
305export interface CreateReFungibleData extends Struct {};356export interface CreateReFungibleData extends Struct {}
306export interface CreateNftData extends Struct {};357export interface CreateNftData extends Struct {}
307358
308export interface CreateItemData extends Enum {359export interface CreateItemData extends Enum {
309  NFT: CreateNftData,360  NFT: CreateNftData;
310  Fungible: CreateFungibleData,361  Fungible: CreateFungibleData;
311  ReFungible: CreateReFungibleData362  ReFungible: CreateReFungibleData;
312};363}
364
365export async function
366approveExpectSuccess(collectionId: number,
367                     tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {
368  await usingApi(async (api: ApiPromise) => {
369    const allowanceBefore =
370      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;
371    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);
372    const events = await submitTransactionAsync(owner, approveNftTx);
373    const result = getCreateItemResult(events);
374    // tslint:disable-next-line:no-unused-expression
375    expect(result.success).to.be.true;
376    const allowanceAfter =
377      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;
378    expect(allowanceAfter.toNumber() - allowanceBefore.toNumber()).to.be.equal(amount);
379  });
380}
381
382export async function
383transferFromExpectSuccess(collectionId: number, tokenId: number, accountFrom: IKeyringPair,
384                          accountTo: IKeyringPair, value: number = 1, type: string = 'NFT') {
385  await usingApi(async (api: ApiPromise) => {
386    const transferFromTx = await api.tx.nft.transferFrom(
387      accountFrom.address, accountTo.address, collectionId, tokenId, value);
388    const events = await submitTransactionAsync(accountFrom, transferFromTx);
389    const result = getCreateItemResult(events);
390    // tslint:disable-next-line:no-unused-expression
391    expect(result.success).to.be.true;
392    if (type === 'NFT') {
393      const nftItemData = api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;
394      console.log('NFT data', nftItemData);
395    }
396    if (type === 'Fungible') {
397      const nftItemData = api.query.nft.fungibleItemList(collectionId, tokenId) as unknown as ITokenDataType;
398      console.log('Fungible data', nftItemData);
399    }
400    if (type === 'ReFungible') {
401      const nftItemData = api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as ITokenDataType;
402      console.log('reFungibleItemList data', nftItemData);
403    }
404  });
405}
406
407export async function
408approveExpectFail(collectionId: number,
409                  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {
410  await usingApi(async (api: ApiPromise) => {
411    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);
412    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;
413    const result = getCreateCollectionResult(events);
414    // tslint:disable-next-line:no-unused-expression
415    expect(result.success).to.be.false;
416  });
417}
313418
314export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {419export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {
315  let newItemId: number = 0;420  let newItemId: number = 0;
316  await usingApi(async (api) => {421  await usingApi(async (api) => {
317    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString());422    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);
318    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();    423    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();
319    const AItemBalance = new BigNumber(Aitem.Value);424    const AItemBalance = new BigNumber(Aitem.Value);
320425
321    if (owner === '') owner = sender.address;426    if (owner === '') {
427      owner = sender.address;
428    }
322429
323    let tx;430    let tx;
324    if (createMode == 'Fungible') {431    if (createMode === 'Fungible') {
325      let createData = {fungible: {value: 10}};432      const createData = {fungible: {value: 10}};
326      tx = api.tx.nft.createItem(collectionId, owner, createData);433      tx = api.tx.nft.createItem(collectionId, owner, createData);
327    }434    } else {
328    else {
329      tx = api.tx.nft.createItem(collectionId, owner, createMode);435      tx = api.tx.nft.createItem(collectionId, owner, createMode);
330    }436    }
331    const events = await submitTransactionAsync(sender, tx);437    const events = await submitTransactionAsync(sender, tx);
332    const result = getCreateItemResult(events);438    const result = getCreateItemResult(events);
333439
334    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString());440    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);
335    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();    441    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();
336    const BItemBalance = new BigNumber(Bitem.Value);442    const BItemBalance = new BigNumber(Bitem.Value);
337443
338    // What to expect444    // What to expect
445    // tslint:disable-next-line:no-unused-expression
339    expect(result.success).to.be.true;446    expect(result.success).to.be.true;
340    if (createMode == 'Fungible') {447    if (createMode === 'Fungible') {
341      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);448      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);
342    }449    } else {
343    else {
358    const events = await submitTransactionAsync(sender, tx);464    const events = await submitTransactionAsync(sender, tx);
359    const result = getGenericResult(events);465    const result = getGenericResult(events);
360466
361    // Get the collection 467    // Get the collection
362    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();468    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
363469
364    // What to expect470    // What to expect
375    const events = await submitTransactionAsync(sender, tx);481    const events = await submitTransactionAsync(sender, tx);
376    const result = getGenericResult(events);482    const result = getGenericResult(events);
377483
378    // Get the collection 484    // Get the collection
379    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();485    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
380486
381    // What to expect487    // What to expect
392    const events = await submitTransactionAsync(sender, tx);498    const events = await submitTransactionAsync(sender, tx);
393    const result = getGenericResult(events);499    const result = getGenericResult(events);
394500
395    // Get the collection 501    // Get the collection
396    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();502    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();
397503
398    // What to expect504    // What to expect