`8154d7d843bf`

5 files changed

modifiedtests/package.jsondiff before after both

28    "testTransferFrom": "mocha --timeout 9999999 -r ts-node/register ./**/transferFrom.test.ts",28    "testTransferFrom": "mocha --timeout 9999999 -r ts-node/register ./**/transferFrom.test.ts",
29    "testCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",29    "testCreateCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
30    "testToggleContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/toggleContractWhiteList.test.ts",30    "testToggleContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/toggleContractWhiteList.test.ts",
31    "testAddToContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/addToContractWhiteList.test.ts"31    "testAddToContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/addToContractWhiteList.test.ts",
32    "testTransfer": "mocha --timeout 9999999 -r ts-node/register ./**/transfer.test.ts"
32  },33  },
33  "author": "",34  "author": "",
34  "license": "Apache 2.0",35  "license": "Apache 2.0",

modifiedtests/src/substrate/get-balance.tsdiff before after both

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 { ApiPromise } from "@polkadot/api";6import { ApiPromise } from '@polkadot/api';
7import promisifySubstrate from "./promisify-substrate";7import {AccountInfo} from '@polkadot/types/interfaces/system';
8import {AccountInfo} from "@polkadot/types/interfaces/system";8import promisifySubstrate from './promisify-substrate';
99
10export default async function getBalance(api: ApiPromise, accounts: string[]): Promise<bigint[]> {10export default async function getBalance(api: ApiPromise, accounts: string[]): Promise<Array<bigint>> {
11  const balance = promisifySubstrate(api, (accounts: string[]) => api.query.system.account.multi(accounts));11  const balance = promisifySubstrate(api, (acc: string[]) => api.query.system.account.multi(acc));
12  const responce = await balance(accounts) as unknown as AccountInfo[];12  const responce = await balance(accounts) as unknown as AccountInfo[];
13  return responce.map(r => r.data.free.toBigInt().valueOf());13  return responce.map((r) => r.data.free.toBigInt().valueOf());
14}14}
1515

modifiedtests/src/substrate/substrate-api.tsdiff before after both

6060
61export function submitTransactionAsync(sender: IKeyringPair, transaction: SubmittableExtrinsic<ApiTypes>): Promise<EventRecord[]> {61export function
62submitTransactionAsync(sender: IKeyringPair, transaction: SubmittableExtrinsic<ApiTypes>): Promise<EventRecord[]> {
62  return new Promise(async function(resolve, reject) {63  return new Promise(async (resolve, reject) => {
63    try {64    try {
64      await transaction.signAndSend(sender, ({ events = [], status }) => {65      await transaction.signAndSend(sender, ({ events = [], status }) => {
65        const transactionStatus = getTransactionStatus(events, status);66        const transactionStatus = getTransactionStatus(events, status);
6667
67        if (transactionStatus == TransactionStatus.Success) {68        if (transactionStatus === TransactionStatus.Success) {
68          resolve(events);69          resolve(events);
69        } else if (transactionStatus == TransactionStatus.Fail) {70        } else if (transactionStatus === TransactionStatus.Fail) {
70          console.log(`Something went wrong with transaction. Status: ${status}`);71          console.log(`Something went wrong with transaction. Status: ${status}`);
71          reject(events);72          reject(events);
72        }73        }
73      });74      });
74    } catch (e) {75    } catch (e) {
75      console.log("Error: ", e);76      console.log('Error: ', e);
76      reject(e);77      reject(e);
77    }78    }
78  });79  });

modifiedtests/src/transfer.test.tsdiff before after both

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 { expect, assert } from "chai";6import { ApiPromise } from '@polkadot/api';
7import { default as usingApi, submitTransactionAsync } from "./substrate/substrate-api";7import { expect } from 'chai';
8import { alicesPublicKey, bobsPublicKey, ferdiesPublicKey } from "./accounts";8import { alicesPublicKey, bobsPublicKey } from './accounts';
9import privateKey from "./substrate/privateKey";9import getBalance from './substrate/get-balance';
10import getBalance from "./substrate/get-balance";10import privateKey from './substrate/privateKey';
11import { BigNumber } from 'bignumber.js';11import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
12import { findUnusedAddress } from './util/helpers'12import {
13  approveExpectSuccess,
14  createCollectionExpectSuccess, createItemExpectSuccess,
15  findUnusedAddress,
16  getCreateCollectionResult,
17  getCreateItemResult,
18  transferExpectSuccess,
19} from './util/helpers';
1320
14describe('Transfer', () => {21describe('Integration Test Transfer(recipient, collection_id, item_id, value)', () => {
15  it('Balance transfers', async () => {22  it('Balance transfers and check balance', async () => {
16    await usingApi(async api => {23    await usingApi(async (api: ApiPromise) => {
17      const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);24      const [alicesBalanceBefore, bobsBalanceBefore] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);
1825
19      const alicePrivateKey = privateKey('//Alice');26      const alicePrivateKey = privateKey('//Alice');
20      27
21      const transfer = api.tx.balances.transfer(bobsPublicKey, 1n);28      const transfer = api.tx.balances.transfer(bobsPublicKey, 1n);
22      const result = await submitTransactionAsync(alicePrivateKey, transfer);29      const events = await submitTransactionAsync(alicePrivateKey, transfer);
30      const result = getCreateItemResult(events);
31      // tslint:disable-next-line:no-unused-expression
32      expect(result.success).to.be.true;
2333
24      const [alicesBalanceAfter, bobsBalanceAfter] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);34      const [alicesBalanceAfter, bobsBalanceAfter] = await getBalance(api, [alicesPublicKey, bobsPublicKey]);
2535
36      // tslint:disable-next-line:no-unused-expression
26      expect(alicesBalanceAfter < alicesBalanceBefore).to.be.true;37      expect(alicesBalanceAfter < alicesBalanceBefore).to.be.true;
38      // tslint:disable-next-line:no-unused-expression
27      expect(bobsBalanceAfter > bobsBalanceBefore).to.be.true;39      expect(bobsBalanceAfter > bobsBalanceBefore).to.be.true;
28    });40    });
29  });41  });
3042
31  it('Inability to pay fees error message is correct', async () => {43  it('Inability to pay fees error message is correct', async () => {
32    await usingApi(async api => {44    await usingApi(async (api) => {
33      // Find unused address45      // Find unused address
34      const pk = await findUnusedAddress(api);46      const pk = await findUnusedAddress(api);
3547
36      const error = console.error;
37      const log = console.log;
38      console.log = function () {};
39      console.error = function () {};
40  
41      const badTransfer = api.tx.balances.transfer(bobsPublicKey, 1n);48      const badTransfer = api.tx.balances.transfer(bobsPublicKey, 1n);
49      // const events = await submitTransactionAsync(pk, badTransfer);
42      const badTransaction = async function () { 50      const badTransaction = async () => {
43        const result = await submitTransactionAsync(pk, badTransfer);51        const events = await submitTransactionAsync(pk, badTransfer);
52        const result = getCreateCollectionResult(events);
53        // tslint:disable-next-line:no-unused-expression
54        expect(result.success).to.be.false;
44      };55      };
45      await expect(badTransaction()).to.be.rejectedWith("Inability to pay some fees");56      expect(badTransaction()).to.be.rejectedWith('Inability to pay some fees , e.g. account balance too low');
46
47      console.log = log;
48      console.error = error;
49    });57    });
50  });58  });
59
60  it('Create collection, balance transfers and check balance', async () => {
61    const Alice = privateKey('//Alice');
62    const Bob = privateKey('//Bob');
63    const Charlie = privateKey('//CHARLIE');
64    // nft
65    const nftCollectionId = await createCollectionExpectSuccess();
66    const newNftTokenId = await createItemExpectSuccess(Alice, nftCollectionId, 'NFT');
67
68    await transferExpectSuccess(nftCollectionId, newNftTokenId, Alice, Bob, 1, 'NFT');
69
70    // fungible
71    const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
72    const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
73    await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
74    await transferExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob, 1, 'Fungible');
75    // reFungible
76    const reFungibleCollectionId = await
77      createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
78    const newReFungibleTokenId = await createItemExpectSuccess(Alice, reFungibleCollectionId, 'ReFungible');
79    await approveExpectSuccess(reFungibleCollectionId, newReFungibleTokenId, Alice, Bob);
80    await transferExpectSuccess(reFungibleCollectionId,
81      newReFungibleTokenId, Alice, Bob, 1, 'ReFungible');
82  });
51});83});
84
85describe('Negative Integration Test Transfer(recipient, collection_id, item_id, value)', () => {
86  it('Transfer with not existed collection_id', async () => {
87
88  });
89  it('Transfer with deleted collection_id', async () => {
90
91  });
92  it('Transfer with not existed item_id', async () => {
93
94  });
95  it('Transfer with deleted item_id', async () => {
96
97  });
98  it('Transfer with recipient that is not owner', async () => {
99
100  });
101});
52102

modifiedtests/src/util/helpers.tsdiff before after both

461  });461  });
462}462}
463
464export async function
465transferExpectSuccess(collectionId: number,
466                      tokenId: number,
467                      sender: IKeyringPair,
468                      recipient: IKeyringPair,
469                      value: number = 1,
470                      type: string = 'NFT') {
471  await usingApi(async (api: ApiPromise) => {
472    let balanceBefore = new BN(0);
473    if (type === 'Fungible') {
474      balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;
475    }
476    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);
477    const events = await submitTransactionAsync(sender, transferTx);
478    const result = getCreateItemResult(events);
479    // tslint:disable-next-line:no-unused-expression
480    expect(result.success).to.be.true;
481    if (type === 'NFT') {
482      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;
483      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);
484    }
485    if (type === 'Fungible') {
486      const balanceAfter = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;
487      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);
488    }
489    if (type === 'ReFungible') {
490      const nftItemData =
491        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;
492      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);
493      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);
494    }
495  });
496}
463497
464export async function498export async function
465approveExpectFail(collectionId: number,499approveExpectFail(collectionId: number,