git.delta.rocks / unique-network / refs/commits / 39dc916474d4

32    "testRemoveFromWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromWhiteList.test.ts",32    "testRemoveFromWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromWhiteList.test.ts",
33    "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",33    "testConnection": "mocha --timeout 9999999 -r ts-node/register ./**/connection.test.ts",
34    "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",34    "testCollection": "mocha --timeout 9999999 -r ts-node/register ./**/createCollection.test.ts",
35    "testContracts": "mocha --timeout 9999999 -r ts-node/register ./**/contracts.test.ts",
35    "testCreateItem": "mocha --timeout 9999999 -r ts-node/register ./**/createItem.test.ts",36    "testCreateItem": "mocha --timeout 9999999 -r ts-node/register ./**/createItem.test.ts",
36    "testCreateMultipleItems": "mocha --timeout 9999999 -r ts-node/register ./**/createMultipleItems.test.ts",37    "testCreateMultipleItems": "mocha --timeout 9999999 -r ts-node/register ./**/createMultipleItems.test.ts",
37    "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts",38    "testApprove": "mocha --timeout 9999999 -r ts-node/register ./**/approve.test.ts",
44    "testSetMintPermission": "mocha --timeout 9999999 -r ts-node/register ./**/setMintPermission.test.ts",45    "testSetMintPermission": "mocha --timeout 9999999 -r ts-node/register ./**/setMintPermission.test.ts",
45    "testCreditFeesToTreasury": "mocha --timeout 9999999 -r ts-node/register ./**/creditFeesToTreasury.test.ts",46    "testCreditFeesToTreasury": "mocha --timeout 9999999 -r ts-node/register ./**/creditFeesToTreasury.test.ts",
46    "testEnableContractSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/enableContractSponsoring.test.ts",47    "testEnableContractSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/enableContractSponsoring.test.ts",
48    "testRemoveFromContractWhiteList": "mocha --timeout 9999999 -r ts-node/register ./**/removeFromContractWhiteList.test.ts",
47    "testSetContractSponsoringRateLimit": "mocha --timeout 9999999 -r ts-node/register ./**/setContractSponsoringRateLimit.test.ts",49    "testSetContractSponsoringRateLimit": "mocha --timeout 9999999 -r ts-node/register ./**/setContractSponsoringRateLimit.test.ts",
48    "testSetOffchainSchema": "mocha --timeout 9999999 -r ts-node/register ./**/setOffchainSchema.test.ts",50    "testSetOffchainSchema": "mocha --timeout 9999999 -r ts-node/register ./**/setOffchainSchema.test.ts",
49    "testOverflow": "mocha --timeout 9999999 -r ts-node/register ./**/overflow.test.ts",51    "testOverflow": "mocha --timeout 9999999 -r ts-node/register ./**/overflow.test.ts",

123    // nft123    // nft
124    const nftCollectionId = await createCollectionExpectSuccess();124    const nftCollectionId = await createCollectionExpectSuccess();
125    await approveExpectFail(nftCollectionId, 2, Alice, Bob);125    await approveExpectFail(nftCollectionId, 2, Alice, Bob);
126    // fungible
127    const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
128    await approveExpectFail(fungibleCollectionId, 2, Alice, Bob);
129    // reFungible126    // reFungible
130    const reFungibleCollectionId =127    const reFungibleCollectionId =
131      await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});128      await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});

46      // tslint:disable-next-line:no-unused-expression46      // tslint:disable-next-line:no-unused-expression
47      expect(result.success).to.be.true;47      expect(result.success).to.be.true;
48      // tslint:disable-next-line:no-unused-expression48      // tslint:disable-next-line:no-unused-expression
49      expect(item).to.be.not.null;49      expect(item).to.be.null;
50      expect(item.Owner).to.be.equal(nullPublicKey);
51    });50    });
5251
53  });52  });
88      87      
89      // What to expect88      // What to expect
90      expect(result.success).to.be.true;89      expect(result.success).to.be.true;
91      expect(balance).to.be.not.null;90      expect(balance).to.be.null;
92      expect(balance.Owner.length).to.be.equal(0);
93    });91    });
9492
95  });93  });

63      const collectionId = await createCollectionExpectSuccess();63      const collectionId = await createCollectionExpectSuccess();
64      const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');64      const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
65      const [contract, deployer] = await deployTransferContract(api);65      const [contract, deployer] = await deployTransferContract(api);
66      const tokenBefore: any = await api.query.nft.nftItemList(collectionId, tokenId);66      const tokenBefore: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap();
67      67      
68      // Transfer68      // Transfer
69      const transferTx = contract.tx.transfer(value, gasLimit, bob.address, collectionId, tokenId, 1);69      const transferTx = contract.tx.transfer(value, gasLimit, bob.address, collectionId, tokenId, 1);
70      const events = await submitTransactionAsync(alice, transferTx);70      const events = await submitTransactionAsync(alice, transferTx);
71      const result = getGenericResult(events);71      const result = getGenericResult(events);
72      const tokenAfter: any = await api.query.nft.nftItemList(collectionId, tokenId);72      const tokenAfter: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap();
7373
74      // tslint:disable-next-line:no-unused-expression74      // tslint:disable-next-line:no-unused-expression
75      expect(result.success).to.be.true;75      expect(result.success).to.be.true;

38      await submitTransactionAsync(Alice, createMultipleItemsTx);38      await submitTransactionAsync(Alice, createMultipleItemsTx);
39      const itemsListIndexAfter = await api.query.nft.itemListIndex(collectionId) as unknown as BN;39      const itemsListIndexAfter = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
40      expect(itemsListIndexAfter.toNumber()).to.be.equal(3);40      expect(itemsListIndexAfter.toNumber()).to.be.equal(3);
41      const token1Data = await api.query.nft.nftItemList(collectionId, 1) as unknown as ITokenDataType;41      const token1Data = (await api.query.nft.nftItemList(collectionId, 1)).toJSON() as unknown as ITokenDataType;
42      const token2Data = await api.query.nft.nftItemList(collectionId, 2) as unknown as ITokenDataType;42      const token2Data = (await api.query.nft.nftItemList(collectionId, 2)).toJSON() as unknown as ITokenDataType;
43      const token3Data = await api.query.nft.nftItemList(collectionId, 3) as unknown as ITokenDataType;43      const token3Data = (await api.query.nft.nftItemList(collectionId, 3)).toJSON() as unknown as ITokenDataType;
4444
45      expect(token1Data.Owner.toString()).to.be.equal(Alice.address);45      expect(token1Data.Owner.toString()).to.be.equal(Alice.address);
46      expect(token2Data.Owner.toString()).to.be.equal(Alice.address);46      expect(token2Data.Owner.toString()).to.be.equal(Alice.address);
72      await submitTransactionAsync(Alice, createMultipleItemsTx);72      await submitTransactionAsync(Alice, createMultipleItemsTx);
73      const itemsListIndexAfter = await api.query.nft.itemListIndex(collectionId) as unknown as BN;73      const itemsListIndexAfter = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
74      expect(itemsListIndexAfter.toNumber()).to.be.equal(3);74      expect(itemsListIndexAfter.toNumber()).to.be.equal(3);
75      const token1Data = await api.query.nft.reFungibleItemList(collectionId, 1) as unknown as IReFungibleTokenDataType;75      const token1Data = (await api.query.nft.reFungibleItemList(collectionId, 1) as any).unwrap() as unknown as IReFungibleTokenDataType;
76      const token2Data = await api.query.nft.reFungibleItemList(collectionId, 2) as unknown as IReFungibleTokenDataType;76      const token2Data = (await api.query.nft.reFungibleItemList(collectionId, 2) as any).unwrap() as unknown as IReFungibleTokenDataType;
77      const token3Data = await api.query.nft.reFungibleItemList(collectionId, 3) as unknown as IReFungibleTokenDataType;77      const token3Data = (await api.query.nft.reFungibleItemList(collectionId, 3) as any).unwrap() as unknown as IReFungibleTokenDataType;
7878
79      expect(token1Data.Owner[0].Owner.toString()).to.be.equal(Alice.address);79      expect(token1Data.Owner[0].Owner.toString()).to.be.equal(Alice.address);
80      expect(token1Data.Owner[0].Fraction.toNumber()).to.be.equal(1);80      expect(token1Data.Owner[0].Fraction.toNumber()).to.be.equal(1);

37    });37    });
38  });38  });
39
40  it('Remove admin from collection that has no admins', async () => {
41    await usingApi(async (api: ApiPromise) => {
42      const Alice = privateKey('//Alice');
43      const collectionId = await createCollectionExpectSuccess();
44
45      const adminListBeforeAddAdmin: any = (await api.query.nft.adminList(collectionId));
46      expect(adminListBeforeAddAdmin).to.have.lengthOf(0);
47
48      const tx = api.tx.nft.removeCollectionAdmin(collectionId, Alice.address);
49      await submitTransactionAsync(Alice, tx);
50    });
51  });
39});52});
4053
41describe('Negative Integration Test removeCollectionAdmin(collection_id, account_id):', () => {54describe('Negative Integration Test removeCollectionAdmin(collection_id, account_id):', () => {
71    });84    });
72  });85  });
73
74  it('Remove admin from collection that has no admins', async () => {
75    await usingApi(async (api: ApiPromise) => {
76      const Alice = privateKey('//Alice');
77      const collectionId = await createCollectionExpectSuccess();
78
79      const adminListBeforeAddAdmin: any = (await api.query.nft.adminList(collectionId));
80      expect(adminListBeforeAddAdmin).to.have.lengthOf(0);
81
82      const tx = api.tx.nft.removeCollectionAdmin(collectionId, Alice.address);
83      await expect(submitTransactionExpectFailAsync(Alice, tx)).to.be.rejected;
84    });
85  });
86});86});
8787

13describe('Integration Test removeFromContractWhiteList', () => {13describe('Integration Test removeFromContractWhiteList', () => {
14    let bob: IKeyringPair;14    let bob: IKeyringPair;
1515
16    before(() => {16    before(async () => {
17        await usingApi(async () => {
17        bob = privateKey('//Bob');18            bob = privateKey('//Bob');
18    });19        });
20    });
1921
20    it('user is no longer whitelisted after removal', async () => {22    it('user is no longer whitelisted after removal', async () => {
56    let alice: IKeyringPair;58    let alice: IKeyringPair;
57    let bob: IKeyringPair;59    let bob: IKeyringPair;
5860
59    before(() => {61    before(async () => {
62        await usingApi(async () => {
60        alice = privateKey('//Alice');63            alice = privateKey('//Alice');
61        bob = privateKey('//Bob');64            bob = privateKey('//Bob');
62    });65        });
66    });
6367
64    it('fails when called with non-contract address', async () => {68    it('fails when called with non-contract address', async () => {

4141
42  it('verify data was set', async () => {42  it('verify data was set', async () => {
43    await usingApi(async api => {43    await usingApi(async api => {
44      const item: any = await api.query.nft.nftItemList(collectionId, tokenId);44      const item: any = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap();
4545
46      expect(Array.from(item.VariableData)).to.deep.equal(Array.from(data));46      expect(Array.from(item.VariableData)).to.deep.equal(Array.from(data));
47    });47    });

237      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});237      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
238      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');238      const newFungibleTokenId = await createItemExpectSuccess(Alice, fungibleCollectionId, 'Fungible');
239      await burnItemExpectSuccess(Alice, fungibleCollectionId, 1, 10);239      await burnItemExpectSuccess(Alice, fungibleCollectionId, 1, 10);
240      await approveExpectFail(fungibleCollectionId, newFungibleTokenId, Alice, Bob);240      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, Alice, Bob);
241      await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1);241      await transferFromExpectFail(fungibleCollectionId, newFungibleTokenId, Bob, Alice, Charlie, 1);
242          242          
243    });243    });

599    // tslint:disable-next-line:no-unused-expression599    // tslint:disable-next-line:no-unused-expression
600    expect(result.success).to.be.true;600    expect(result.success).to.be.true;
601    // tslint:disable-next-line:no-unused-expression601    // tslint:disable-next-line:no-unused-expression
602    expect(item).to.be.not.null;602    expect(item).to.be.null;
603    expect(item.Owner).to.be.equal(nullPublicKey);
604  });603  });
605}604}
606605
641    // tslint:disable-next-line:no-unused-expression640    // tslint:disable-next-line:no-unused-expression
642    expect(result.success).to.be.true;641    expect(result.success).to.be.true;
643    if (type === 'NFT') {642    if (type === 'NFT') {
644      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;643      const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId) as any).unwrap() as ITokenDataType;
645      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);644      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);
646    }645    }
647    if (type === 'Fungible') {646    if (type === 'Fungible') {
648      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;647      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, accountTo.address) as any).Value as unknown as BN;
649      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());648      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());
650    }649    }
651    if (type === 'ReFungible') {650    if (type === 'ReFungible') {
652      const nftItemData =651      const nftItemData =
653        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;652        (await api.query.nft.reFungibleItemList(collectionId, tokenId) as any).unwrap() as IReFungibleTokenDataType;
654      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);653      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);
655      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);654      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);
656    }655    }
697    expect(result.recipient).to.be.equal(recipient.address);696    expect(result.recipient).to.be.equal(recipient.address);
698    expect(result.value.toString()).to.be.equal(value.toString());697    expect(result.value.toString()).to.be.equal(value.toString());
699    if (type === 'NFT') {698    if (type === 'NFT') {
700      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;699      const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;
701      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);700      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);
702    }701    }
703    if (type === 'Fungible') {702    if (type === 'Fungible') {
704      const balanceAfter = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;703      const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, recipient.address) as any).Value as unknown as BN;
705      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());704      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());
706    }705    }
707    if (type === 'ReFungible') {706    if (type === 'ReFungible') {
708      const nftItemData =707      const nftItemData =
709        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;708        (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON() as unknown as IReFungibleTokenDataType;
710      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);709      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);
711      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);710      expect(nftItemData.Owner[0].Fraction.toString()).to.be.equal(value.toString());
712    }711    }
713  });712  });
714}713}