git.delta.rocks / unique-network / refs/commits / be0c28ab6ce3

difftreelog

transferFrom tests

kpozdnikin2021-01-18parent: #f8c3f30.patch.diff
in: master

3 files changed

modifiedtests/src/approve.test.tsdiffbeforeafterboth
7import chai from 'chai';7import chai from 'chai';
8import chaiAsPromised from 'chai-as-promised';8import chaiAsPromised from 'chai-as-promised';
9import privateKey from './substrate/privateKey';9import privateKey from './substrate/privateKey';
10import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';10import { default as usingApi } from './substrate/substrate-api';
11import {11import {
12  approveExpectFail,12  approveExpectFail,
13  approveExpectSuccess,13  approveExpectSuccess,
29      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');29      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
30      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);30      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
31      // fungible31      // fungible
32      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});32      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
33      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');33      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
34      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);34      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
35      // reFungible35      // reFungible
36      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});36      const reFungibleCollectionId =
37        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
37      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');38      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
38      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);39      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
3940
54      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1);55      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1);
55      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 0);56      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 0);
56      // fungible57      // fungible
57      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});58      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
58      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');59      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
59      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1);60      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1);
60      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 0);61      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 0);
61      // reFungible62      // reFungible
62      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});63      const reFungibleCollectionId =
64        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
63      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');65      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
64      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 1);66      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 1);
65      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 0);67      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob, 0);
81      const nftCollectionId = await createCollectionExpectSuccess();83      const nftCollectionId = await createCollectionExpectSuccess();
82      await approveExpectFail(nftCollectionId + 1, 1, Alice, Bob);84      await approveExpectFail(nftCollectionId + 1, 1, Alice, Bob);
83      // fungible85      // fungible
84      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});86      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
85      await approveExpectFail(fungibleCollectionId + 1, 1, Alice, Bob);87      await approveExpectFail(fungibleCollectionId + 1, 1, Alice, Bob);
86      // reFungible88      // reFungible
87      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});89      const reFungibleCollectionId =
90        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
88      await approveExpectFail(reFungibleCollectionId + 1, 1, Alice, Bob);91      await approveExpectFail(reFungibleCollectionId + 1, 1, Alice, Bob);
89      // garbage collection :-D92      // garbage collection :-D
90      await destroyCollectionExpectSuccess(nftCollectionId);93      await destroyCollectionExpectSuccess(nftCollectionId);
102      await destroyCollectionExpectSuccess(nftCollectionId);105      await destroyCollectionExpectSuccess(nftCollectionId);
103      await approveExpectFail(nftCollectionId, 1, Alice, Bob);106      await approveExpectFail(nftCollectionId, 1, Alice, Bob);
104      // fungible107      // fungible
105      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});108      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
106      await destroyCollectionExpectSuccess(fungibleCollectionId);109      await destroyCollectionExpectSuccess(fungibleCollectionId);
107      await approveExpectFail(fungibleCollectionId, 1, Alice, Bob);110      await approveExpectFail(fungibleCollectionId, 1, Alice, Bob);
108      // reFungible111      // reFungible
109      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});112      const reFungibleCollectionId =
113        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
110      await destroyCollectionExpectSuccess(reFungibleCollectionId);114      await destroyCollectionExpectSuccess(reFungibleCollectionId);
111      await approveExpectFail(reFungibleCollectionId, 1, Alice, Bob);115      await approveExpectFail(reFungibleCollectionId, 1, Alice, Bob);
112    });116    });
120      const nftCollectionId = await createCollectionExpectSuccess();124      const nftCollectionId = await createCollectionExpectSuccess();
121      await approveExpectFail(nftCollectionId, 2, Alice, Bob);125      await approveExpectFail(nftCollectionId, 2, Alice, Bob);
122      // fungible126      // fungible
123      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});127      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
124      await approveExpectFail(fungibleCollectionId, 2, Alice, Bob);128      await approveExpectFail(fungibleCollectionId, 2, Alice, Bob);
125      // reFungible129      // reFungible
126      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});130      const reFungibleCollectionId =
131        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
127      await approveExpectFail(reFungibleCollectionId, 2, Alice, Bob);132      await approveExpectFail(reFungibleCollectionId, 2, Alice, Bob);
128      // garbage collection :-D133      // garbage collection :-D
129      await destroyCollectionExpectSuccess(nftCollectionId);134      await destroyCollectionExpectSuccess(nftCollectionId);
141      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');146      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
142      await approveExpectFail(nftCollectionId, newNftTokenId, Bob, Alice);147      await approveExpectFail(nftCollectionId, newNftTokenId, Bob, Alice);
143      // fungible148      // fungible
144      const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});149      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
145      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');150      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
146      await approveExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice);151      await approveExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice);
147      // reFungible152      // reFungible
148      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});153      const reFungibleCollectionId =
154        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
149      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');155      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
150      await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Bob, Alice);156      await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Bob, Alice);
151157
modifiedtests/src/transferFrom.test.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//
5import { ApiPromise } from '@polkadot/api';5import { ApiPromise } from '@polkadot/api';
6import BN from 'bn.js';
7import chai from 'chai';6import chai from 'chai';
8import chaiAsPromised from 'chai-as-promised';7import chaiAsPromised from 'chai-as-promised';
9import privateKey from './substrate/privateKey';8import privateKey from './substrate/privateKey';
10import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';9import { default as usingApi } from './substrate/substrate-api';
11import {10import {
11  approveExpectFail,
12  approveExpectSuccess,12  approveExpectSuccess,
13  createCollectionExpectSuccess,13  createCollectionExpectSuccess,
14  createItemExpectSuccess,14  createItemExpectSuccess,
15  destroyCollectionExpectSuccess,15  destroyCollectionExpectSuccess,
16  transferFromExpectFail,
16  transferFromExpectSuccess,17  transferFromExpectSuccess,
17} from './util/helpers';18} from './util/helpers';
18import {IKeyringPair} from "@polkadot/types/types";
1919
20chai.use(chaiAsPromised);20chai.use(chaiAsPromised);
21const expect = chai.expect;21const expect = chai.expect;
26      const Alice = privateKey('//Alice');26      const Alice = privateKey('//Alice');
27      const Bob = privateKey('//Bob');27      const Bob = privateKey('//Bob');
28      const Charlie = privateKey('//CHARLIE');28      const Charlie = privateKey('//CHARLIE');
29      // nft
29      const nftCollectionId = await createCollectionExpectSuccess();30      const nftCollectionId = await createCollectionExpectSuccess();
30      console.log('nftCollectionId', nftCollectionId);31      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
32      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
33
34      await transferFromExpectSuccess(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1, 'NFT');
35
36      // fungible
31      const collectionInfo = await api.query.nft.collection(nftCollectionId);37      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
38      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
32      console.log('collectionInfo', collectionInfo);39      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
33      // nft40      await transferFromExpectSuccess(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1, 'Fungible');
41      // reFungible
42      const reFungibleCollectionId = await
43        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
34      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');44      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
35      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);45      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
36
37      await transferFromExpectSuccess(nftCollectionId, newNftTokenId, Alice, Charlie, 1, 'NFT');46      await transferFromExpectSuccess(reFungibleCollectionId,
3847        newReFungibleTokenId, Bob, Alice, Charlie, 1, 'ReFungible');
39      // fungible
40      /*const fungibleCollectionId = await createCollectionExpectSuccess({mode: 'Fungible'});
41      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
42      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
43      // reFungible
44      const reFungibleCollectionId = await createCollectionExpectSuccess({mode: 'ReFungible'});
45      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
46      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);*/
4748
48      // garbage collection :-D49      // garbage collection :-D
49      await destroyCollectionExpectSuccess(nftCollectionId);50      await destroyCollectionExpectSuccess(nftCollectionId);
50      // await destroyCollectionExpectSuccess(fungibleCollectionId);51      await destroyCollectionExpectSuccess(fungibleCollectionId);
51      // await destroyCollectionExpectSuccess(reFungibleCollectionId);52      await destroyCollectionExpectSuccess(reFungibleCollectionId);
52    });53    });
53  });54  });
54});55});
5556
56describe('Negative Integration Test transferFrom(from, recipient, collection_id, item_id, value):', () => {57describe('Negative Integration Test transferFrom(from, recipient, collection_id, item_id, value):', () => {
57  it('transferFrom for a collection that does not exist', async () => {58  it('transferFrom for a collection that does not exist', async () => {
58    await usingApi(async (api: ApiPromise) => {59    await usingApi(async (api: ApiPromise) => {
5960      const Alice = privateKey('//Alice');
61      const Bob = privateKey('//Bob');
62      const Charlie = privateKey('//CHARLIE');
63      // nft
64      const nftCollectionId = await createCollectionExpectSuccess();
65      await approveExpectFail(nftCollectionId + 1, 1, Alice, Bob);
66
67      await transferFromExpectFail(nftCollectionId + 1, 1, Bob, Alice, Charlie, 1);
68
69      // fungible
70      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
71      await approveExpectFail(fungibleCollectionId + 1, 1, Alice, Bob);
72
73      await transferFromExpectFail(fungibleCollectionId + 1, 1, Bob, Alice, Charlie, 1);
74      // reFungible
75      const reFungibleCollectionId = await
76        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
77      await approveExpectFail(reFungibleCollectionId + 1, 1, Alice, Bob);
78
79      await transferFromExpectFail(reFungibleCollectionId + 1, 1, Bob, Alice, Charlie, 1);
80
81      // garbage collection :-D
82      await destroyCollectionExpectSuccess(nftCollectionId);
83      await destroyCollectionExpectSuccess(fungibleCollectionId);
84      await destroyCollectionExpectSuccess(reFungibleCollectionId);
60    });85    });
61  });86  });
6287
63  it('transferFrom for a collection that was destroyed', async () => {88  /* it('transferFrom for a collection that was destroyed', async () => {
64    await usingApi(async (api: ApiPromise) => {89    await usingApi(async (api: ApiPromise) => {
6590      this test copies approve negative test
66    });91    });
67  });92  }); */
6893
69  it('transferFrom a token that does not exist', async () => {94  /* it('transferFrom a token that does not exist', async () => {
70    await usingApi(async (api: ApiPromise) => {95    await usingApi(async (api: ApiPromise) => {
7196      this test copies approve negative test
72    });97    });
73  });98  }); */
7499
75  it('transferFrom a token that was deleted', async () => {100  /* it('transferFrom a token that was deleted', async () => {
76    await usingApi(async (api: ApiPromise) => {101    await usingApi(async (api: ApiPromise) => {
77102      this test copies approve negative test
78    });103    });
79  });104  }); */
80105
81  it('transferFrom for not approved address', async () => {106  it('transferFrom for not approved address', async () => {
82    await usingApi(async (api: ApiPromise) => {107    await usingApi(async (api: ApiPromise) => {
83108      const Alice = privateKey('//Alice');
109      const Bob = privateKey('//Bob');
110      const Charlie = privateKey('//CHARLIE');
111      // nft
112      const nftCollectionId = await createCollectionExpectSuccess();
113      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
114
115      await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 1);
116
117      // fungible
118      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
119      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
120      await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1);
121      // reFungible
122      const reFungibleCollectionId = await
123        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
124      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
125      await transferFromExpectFail(reFungibleCollectionId,
126        newReFungibleTokenId, Bob, Alice, Charlie, 1);
127
128      // garbage collection :-D
129      await destroyCollectionExpectSuccess(nftCollectionId);
130      await destroyCollectionExpectSuccess(fungibleCollectionId);
131      await destroyCollectionExpectSuccess(reFungibleCollectionId);
84    });132    });
85  });133  });
86134
87  it('transferFrom incorrect token count', async () => {135  it('transferFrom incorrect token count', async () => {
88    await usingApi(async (api: ApiPromise) => {136    await usingApi(async (api: ApiPromise) => {
89137      const Alice = privateKey('//Alice');
138      const Bob = privateKey('//Bob');
139      const Charlie = privateKey('//CHARLIE');
140      // nft
141      const nftCollectionId = await createCollectionExpectSuccess();
142      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
143      await approveExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob);
144
145      await transferFromExpectFail(nftCollectionId, newNftTokenId, Bob, Alice, Charlie, 2);
146
147      // fungible
148      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
149      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
150      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
151      await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 2);
152      // reFungible
153      const reFungibleCollectionId = await
154        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
155      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
156      await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
157      await transferFromExpectFail(reFungibleCollectionId,
158        newReFungibleTokenId, Bob, Alice, Charlie, 2);
159
160      // garbage collection :-D
161      await destroyCollectionExpectSuccess(nftCollectionId);
162      await destroyCollectionExpectSuccess(fungibleCollectionId);
163      await destroyCollectionExpectSuccess(reFungibleCollectionId);
90    });164    });
91  });165  });
92166
93  it('execute transferFrom from account that is not owner of collection', async () => {167  it('execute transferFrom from account that is not owner of collection', async () => {
94    await usingApi(async (api: ApiPromise) => {168    await usingApi(async (api: ApiPromise) => {
95169      const Alice = privateKey('//Alice');
170      const Bob = privateKey('//Bob');
171      const Charlie = privateKey('//CHARLIE');
172      const Dave = privateKey('//DAVE');
173      // nft
174      const nftCollectionId = await createCollectionExpectSuccess();
175      const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
176      try {
177        await approveExpectFail(nftCollectionId, newNftTokenId, Dave, Bob);
178        await transferFromExpectFail(nftCollectionId, newNftTokenId, Dave, Alice, Charlie, 1);
179      } catch (e) {
180        // tslint:disable-next-line:no-unused-expression
181        expect(e).to.be.exist;
182      }
183
184      // await transferFromExpectFail(nftCollectionId, newNftTokenId, Dave, Alice, Charlie, 1);
185
186      // fungible
187      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
188      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
189      try {
190        await approveExpectFail(fungibleCollectionId, newFungibleTokenId, Dave, Bob);
191        await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Dave, Alice, Charlie, 1);
192      } catch (e) {
193        // tslint:disable-next-line:no-unused-expression
194        expect(e).to.be.exist;
195      }
196      // reFungible
197      const reFungibleCollectionId = await
198        createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
199      const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
200      try {
201        await approveExpectFail(reFungibleCollectionId, newReFungibleTokenId, Dave, Bob);
202        await transferFromExpectFail(reFungibleCollectionId, newReFungibleTokenId, Dave, Alice, Charlie, 1);
203      } catch (e) {
204        // tslint:disable-next-line:no-unused-expression
205        expect(e).to.be.exist;
206      }
207      // garbage collection :-D
208      await destroyCollectionExpectSuccess(nftCollectionId);
209      await destroyCollectionExpectSuccess(fungibleCollectionId);
210      await destroyCollectionExpectSuccess(reFungibleCollectionId);
96    });211    });
97  });212  });
98});213});
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
36  itemId: number;36  itemId: number;
37}37}
38
39interface IReFungibleOwner {
40  Fraction: BN;
41  Owner: number[];
42}
3843
39interface ITokenDataType {44interface ITokenDataType {
40  Owner: number[];45  Owner: number[];
41  ConstData: number[];46  ConstData: number[];
42  VariableData: number[];47  VariableData: number[];
43}48}
49
50interface IFungibleTokenDataType {
51  Value: BN;
52}
53
54interface IReFungibleTokenDataType {
55  Owner: IReFungibleOwner[];
56  ConstData: number[];
57  VariableData: number[];
58}
4459
45export function getGenericResult(events: EventRecord[]): GenericResult {60export function getGenericResult(events: EventRecord[]): GenericResult {
46  const result: GenericResult = {61  const result: GenericResult = {
396export async function411export async function
397transferFromExpectSuccess(collectionId: number, tokenId: number, accountFrom: IKeyringPair,412transferFromExpectSuccess(collectionId: number,
413                          tokenId: number,
414                          accountApproved: IKeyringPair,
415                          accountFrom: IKeyringPair,
398                          accountTo: IKeyringPair, value: number = 1, type: string = 'NFT') {416                          accountTo: IKeyringPair,
417                          value: number = 1,
418                          type: string = 'NFT') {
399  await usingApi(async (api: ApiPromise) => {419  await usingApi(async (api: ApiPromise) => {
420    let balanceBefore = new BN(0);
421    if (type === 'Fungible') {
422      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;
423    }
400    const transferFromTx = await api.tx.nft.transferFrom(424    const transferFromTx = await api.tx.nft.transferFrom(
401      accountFrom.address, accountTo.address, collectionId, tokenId, value);425      accountFrom.address, accountTo.address, collectionId, tokenId, value);
402    const events = await submitTransactionAsync(accountFrom, transferFromTx);426    const events = await submitTransactionAsync(accountFrom, transferFromTx);
403    const result = getCreateItemResult(events);427    const result = getCreateItemResult(events);
404    // tslint:disable-next-line:no-unused-expression428    // tslint:disable-next-line:no-unused-expression
405    expect(result.success).to.be.true;429    expect(result.success).to.be.true;
406    if (type === 'NFT') {430    if (type === 'NFT') {
407      const nftItemData = api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;431      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;
408      console.log('NFT data', nftItemData);432      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);
409    }433    }
410    if (type === 'Fungible') {434    if (type === 'Fungible') {
411      const nftItemData = api.query.nft.fungibleItemList(collectionId, tokenId) as unknown as ITokenDataType;435      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;
412      console.log('Fungible data', nftItemData);436      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);
413    }437    }
414    if (type === 'ReFungible') {438    if (type === 'ReFungible') {
415      const nftItemData = api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as ITokenDataType;439      const nftItemData =
440        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;
416      console.log('reFungibleItemList data', nftItemData);441      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);
442      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);
417    }443    }
418  });444  });
419}445}
446
447export async function
448transferFromExpectFail(collectionId: number,
449                       tokenId: number,
450                       accountApproved: IKeyringPair,
451                       accountFrom: IKeyringPair,
452                       accountTo: IKeyringPair,
453                       value: number = 1) {
454  await usingApi(async (api: ApiPromise) => {
455    const transferFromTx = await api.tx.nft.transferFrom(
456      accountFrom.address, accountTo.address, collectionId, tokenId, value);
457    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;
458    const result = getCreateCollectionResult(events);
459    // tslint:disable-next-line:no-unused-expression
460    expect(result.success).to.be.false;
461  });
462}
420463
421export async function464export async function
422approveExpectFail(collectionId: number,465approveExpectFail(collectionId: number,