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

10import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';10import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from './substrate/substrate-api';
11import {createCollectionExpectSuccess, destroyCollectionExpectSuccess} from './util/helpers';11import {
12  createCollectionExpectSuccess,
13  destroyCollectionExpectSuccess,
14  IReFungibleTokenDataType,
15} from './util/helpers';
1216
13chai.use(chaiAsPromised);17chai.use(chaiAsPromised);
48      expect(token2Data.VariableData.toString()).to.be.equal('0x32');52      expect(token2Data.VariableData.toString()).to.be.equal('0x32');
49      expect(token3Data.VariableData.toString()).to.be.equal('0x33');53      expect(token3Data.VariableData.toString()).to.be.equal('0x33');
50
51      // garbage collection :-D
52      await destroyCollectionExpectSuccess(collectionId);
53    });54    });
54  });55  });
56
57  it('Create  0x31, 0x32, 0x33 items in active ReFungible collection and verify tokens data in chain', async () => {
58    await usingApi(async (api: ApiPromise) => {
59      const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
60      const itemsListIndexBefore = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
61      expect(itemsListIndexBefore.toNumber()).to.be.equal(0);
62      const Alice = privateKey('//Alice');
63      const args = [
64        { Refungible: ['0x31', '0x31'] },
65        { Refungible: ['0x32', '0x32'] },
66        { Refungible: ['0x33', '0x33'] },
67      ];
68      const createMultipleItemsTx = await api.tx.nft
69        .createMultipleItems(collectionId, Alice.address, args);
70      await submitTransactionAsync(Alice, createMultipleItemsTx);
71      const itemsListIndexAfter = await api.query.nft.itemListIndex(collectionId) as unknown as BN;
72      expect(itemsListIndexAfter.toNumber()).to.be.equal(3);
73      const token1Data = await api.query.nft.reFungibleItemList(collectionId, 1) as unknown as IReFungibleTokenDataType;
74      const token2Data = await api.query.nft.reFungibleItemList(collectionId, 2) as unknown as IReFungibleTokenDataType;
75      const token3Data = await api.query.nft.reFungibleItemList(collectionId, 3) as unknown as IReFungibleTokenDataType;
76
77      expect(token1Data.Owner[0].Owner.toString()).to.be.equal(Alice.address);
78      expect(token1Data.Owner[0].Fraction.toNumber()).to.be.equal(1);
79
80      expect(token2Data.Owner[0].Owner.toString()).to.be.equal(Alice.address);
81      expect(token2Data.Owner[0].Fraction.toNumber()).to.be.equal(1);
82
83      expect(token3Data.Owner[0].Owner.toString()).to.be.equal(Alice.address);
84      expect(token3Data.Owner[0].Fraction.toNumber()).to.be.equal(1);
85
86      expect(token1Data.ConstData.toString()).to.be.equal('0x31');
87      expect(token2Data.ConstData.toString()).to.be.equal('0x32');
88      expect(token3Data.ConstData.toString()).to.be.equal('0x33');
89
90      expect(token1Data.VariableData.toString()).to.be.equal('0x31');
91      expect(token2Data.VariableData.toString()).to.be.equal('0x32');
92      expect(token3Data.VariableData.toString()).to.be.equal('0x33');
93    });
94  });
55});95});
5696
57describe('Negative Integration Test createMultipleItems(collection_id, owner, items_data):', () => {97describe('Negative Integration Test createMultipleItems(collection_id, owner, items_data):', () => {
60      const collectionId = await createCollectionExpectSuccess();100      const collectionId = await createCollectionExpectSuccess();
61      const Alice = privateKey('//Alice');101      const Alice = privateKey('//Alice');
62      try {102      try {
103        const args = [{ invalid: null }, { invalid: null }, { invalid: null }];
63        const createMultipleItemsTx = await api.tx.nft104        const createMultipleItemsTx = await api.tx.nft
64          .createMultipleItems(collectionId, Alice.address, ['UNKNOWN', 'UNKNOWN', 'UNKNOWN']);105          .createMultipleItems(collectionId, Alice.address, args);
65        await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;106        await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
66      } catch (e) {107      } catch (e) {
67        // tslint:disable-next-line:no-unused-expression108        // tslint:disable-next-line:no-unused-expression
68        expect(e).to.be.exist;109        expect(e).to.be.exist;
69      }110      }
70      // garbage collection :-D
71      await destroyCollectionExpectSuccess(collectionId);
72    });111    });
73  });112  });
74113
79      const createMultipleItemsTx = await api.tx.nft118      const createMultipleItemsTx = await api.tx.nft
80        .createMultipleItems(collectionId + 1, Alice.address, ['NFT', 'NFT', 'NFT']);119        .createMultipleItems(collectionId + 1, Alice.address, ['NFT', 'NFT', 'NFT']);
81      await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;120      await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
82      // garbage collection :-D
83      await destroyCollectionExpectSuccess(collectionId);
84    });121    });
85  });122  });
86123
97      const createMultipleItemsTx = await api.tx.nft134      const createMultipleItemsTx = await api.tx.nft
98        .createMultipleItems(collectionId, Alice.address, args);135        .createMultipleItems(collectionId, Alice.address, args);
99      await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;136      await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
100      // garbage collection :-D137
101      await destroyCollectionExpectSuccess(collectionId);138      // ReFungible
102
103      // Fungible
104      const collectionIdFungible = await createCollectionExpectSuccess();139      const collectionIdReFungible =
140        await createCollectionExpectSuccess({mode: {type: 'ReFungible', decimalPoints: 0}});
105      const argsFungible = [141      const argsReFungible = [
106        { fungible: parseInt('1'.repeat(2049), 10) },142        { ReFungible: ['1'.repeat(2049), '1'.repeat(2049)] },
107        { fungible: parseInt('2'.repeat(2049), 10) },143        { ReFungible: ['2'.repeat(2049), '2'.repeat(2049)] },
108        { fungible: parseInt('3'.repeat(2049), 10) },144        { ReFungible: ['3'.repeat(2049), '3'.repeat(2049)] },
109      ];145      ];
110      const createMultipleItemsTxFungible = await api.tx.nft146      const createMultipleItemsTxFungible = await api.tx.nft
111        .createMultipleItems(collectionIdFungible, Alice.address, argsFungible);147        .createMultipleItems(collectionIdReFungible, Alice.address, argsReFungible);
112      await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTxFungible)).to.be.rejected;148      await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTxFungible)).to.be.rejected;
113      // garbage collection :-D
114      await destroyCollectionExpectSuccess(collectionId);
115    });149    });
116  });150  });
117151
139      const createMultipleItemsTx = await api.tx.nft173      const createMultipleItemsTx = await api.tx.nft
140        .createMultipleItems(collectionId, Alice.address, args);174        .createMultipleItems(collectionId, Alice.address, args);
141      await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;175      await expect(submitTransactionExpectFailAsync(Alice, createMultipleItemsTx)).to.be.rejected;
142      // garbage collection :-D
143      await destroyCollectionExpectSuccess(collectionId);
144    });176    });
145  });177  });
146});178});

103      await transaction.signAndSend(sender, ({ events = [], status }) => {103      await transaction.signAndSend(sender, ({ events = [], status }) => {
104        const transactionStatus = getTransactionStatus(events, status);104        const transactionStatus = getTransactionStatus(events, status);
105
106        console.log('transactionStatus', transactionStatus, 'events', events);
107
108        if (transactionStatus == TransactionStatus.Success) {105        if (transactionStatus === TransactionStatus.Success) {
109          resolve(events);106          resolve(events);
110        } else if (transactionStatus == TransactionStatus.Fail) {107        } else if (transactionStatus === TransactionStatus.Fail) {
111          reject(events);108          reject(events);
112        }109        }
113      });110      });

51  Value: BN;51  Value: BN;
52}52}
5353
54interface IReFungibleTokenDataType {54export interface IReFungibleTokenDataType {
55  Owner: IReFungibleOwner[];55  Owner: IReFungibleOwner[];
56  ConstData: number[];56  ConstData: number[];
57  VariableData: number[];57  VariableData: number[];