git.delta.rocks / unique-network / refs/commits / 27a31c97aaab

--- a/tests/src/app-promotion.test.ts
+++ b/tests/src/app-promotion.test.ts
@@ -34,7 +34,10 @@
 let accounts: IKeyringPair[] = [];
 const LOCKING_PERIOD = 20n; // 20 blocks of relay
 const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain
-const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);
+const rewardAvailableInBlock = (stakedInBlock: bigint) => {
+  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + 20n;
+  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);
+};
 
 describe('App promotion', () => {
   before(async function () {

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
18import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
19import {18import {expect, itSub, Pallets, usingPlaygrounds} from './util/playgrounds';
20  createCollectionExpectSuccess,
21  createItemExpectSuccess,
22  getGenericResult,
23  normalizeAccountId,
24  addCollectionAdminExpectSuccess,
25  getBalance,
26  setCollectionLimitsExpectSuccess,
27  isTokenExists,
28  requirePallets,
29  Pallets,
30} from './util/helpers';
3119
32import chai from 'chai';
33import chaiAsPromised from 'chai-as-promised';
34chai.use(chaiAsPromised);
35const expect = chai.expect;
3620
37let alice: IKeyringPair;
38let bob: IKeyringPair;
39
40describe('integration test: ext. burnItem():', () => {21describe('integration test: ext. burnItem():', () => {
22  let donor: IKeyringPair;
23  let alice: IKeyringPair;
24  let bob: IKeyringPair;
25
41  before(async () => {26  before(async () => {
42    await usingApi(async (api, privateKeyWrapper) => {27    await usingPlaygrounds(async (helper, privateKey) => {
43      alice = privateKeyWrapper('//Alice');28      donor = privateKey('//Alice');
44      bob = privateKeyWrapper('//Bob');29      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
45    });30    });
46  });31  });
4732
48  it('Burn item in NFT collection', async () => {33  itSub('Burn item in NFT collection', async ({helper}) => {
49    const createMode = 'NFT';34    const collection = await helper.nft.mintCollection(alice);
50    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
51    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);35    const token = await collection.mintToken(alice);
5236
53    await usingApi(async (api) => {37    await token.burn(alice);
54      const tx = api.tx.unique.burnItem(collectionId, tokenId, 1);
55      const events = await submitTransactionAsync(alice, tx);
56      const result = getGenericResult(events);38    expect(await token.doesExist()).to.be.false;
57
58      expect(result.success).to.be.true;
59      // Get the item
60      expect(await isTokenExists(api, collectionId, tokenId)).to.be.false;
61    });
62  });39  });
6340
64  it('Burn item in Fungible collection', async () => {41  itSub('Burn item in Fungible collection', async ({helper}) => {
65    const createMode = 'Fungible';42    const collection = await helper.ft.mintCollection(alice, {}, 10);
66    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
67    await createItemExpectSuccess(alice, collectionId, createMode); // Helper creates 10 fungible tokens43    await collection.mint(alice, 10n);
68    const tokenId = 0; // ignored
6944
70    await usingApi(async (api) => {45    await collection.burnTokens(alice, 1n);
71      // Destroy 1 of 10
72      const tx = api.tx.unique.burnItem(collectionId, tokenId, 1);
73      const events = await submitTransactionAsync(alice, tx);
74      const result = getGenericResult(events);46    expect(await collection.getBalance({Substrate: alice.address})).to.eq(9n);
75
76      // Get alice balance
77      const balance = await getBalance(api, collectionId, alice.address, 0);
78
79      // What to expect
80      expect(result.success).to.be.true;
81      expect(balance).to.be.equal(9n);
82    });
83  });47  });
8448
85  it('Burn item in ReFungible collection', async function() {49  itSub.ifWithPallets('Burn item in ReFungible collection', [Pallets.ReFungible], async function({helper}) {
86    await requirePallets(this, [Pallets.ReFungible]);50    const collection = await helper.rft.mintCollection(alice);
51    const token = await collection.mintToken(alice, 100n);
8752
88    const createMode = 'ReFungible';53    await token.burn(alice, 90n);
89    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});54    expect(await token.getBalance({Substrate: alice.address})).to.eq(10n);
90    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
9155
92    await usingApi(async (api) => {56    await token.burn(alice, 10n);
93      const tx = api.tx.unique.burnItem(collectionId, tokenId, 100);
94      const events = await submitTransactionAsync(alice, tx);
95      const result = getGenericResult(events);57    expect(await token.getBalance({Substrate: alice.address})).to.eq(0n);
96
97      // Get alice balance
98      const balance = await getBalance(api, collectionId, alice.address, tokenId);
99
100      // What to expect
101      expect(result.success).to.be.true;
102      expect(balance).to.be.equal(0n);
103    });
104  });58  });
10559
106  it('Burn owned portion of item in ReFungible collection', async function() {60  itSub.ifWithPallets('Burn owned portion of item in ReFungible collection', [Pallets.ReFungible], async function({helper}) {
107    await requirePallets(this, [Pallets.ReFungible]);61    const collection = await helper.rft.mintCollection(alice);
62    const token = await collection.mintToken(alice, 100n);
10863
109    const createMode = 'ReFungible';64    await token.transfer(alice, {Substrate: bob.address}, 1n);
110    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
111    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
11265
113    await usingApi(async (api) => {66    expect(await token.getBalance({Substrate: alice.address})).to.eq(99n);
114      // Transfer 1/100 of the token to Bob
115      const transfertx = api.tx.unique.transfer(normalizeAccountId(bob.address), collectionId, tokenId, 1);
116      const events1 = await submitTransactionAsync(alice, transfertx);67    expect(await token.getBalance({Substrate: bob.address})).to.eq(1n);
117      const result1 = getGenericResult(events1);
11868
119      // Get balances69    await token.burn(bob, 1n);
120      const bobBalanceBefore = await getBalance(api, collectionId, bob.address, tokenId);
121      const aliceBalanceBefore = await getBalance(api, collectionId, alice.address, tokenId);
12270
123      // Bob burns his portion71    expect(await token.getBalance({Substrate: alice.address})).to.eq(99n);
124      const tx = api.tx.unique.burnItem(collectionId, tokenId, 1);
125      const events2 = await submitTransactionAsync(bob, tx);
126      const result2 = getGenericResult(events2);
127
128      // Get balances
129      const bobBalanceAfter = await getBalance(api, collectionId, bob.address, tokenId);
130      const aliceBalanceAfter = await getBalance(api, collectionId, alice.address, tokenId);
131      // console.log(balance);
132
133      // What to expect before burning
134      expect(result1.success).to.be.true;
135      expect(aliceBalanceBefore).to.be.equal(99n);
136      expect(bobBalanceBefore).to.be.equal(1n);72    expect(await token.getBalance({Substrate: bob.address})).to.eq(0n);
137
138      // What to expect after burning
139      expect(result2.success).to.be.true;
140      expect(aliceBalanceAfter).to.be.equal(99n);
141      expect(bobBalanceAfter).to.be.equal(0n);
142    });
143
144  });73  });
145
146});74});
14775
148describe('integration test: ext. burnItem() with admin permissions:', () => {76describe('integration test: ext. burnItem() with admin permissions:', () => {
77  let donor: IKeyringPair;
78  let alice: IKeyringPair;
79  let bob: IKeyringPair;
80
149  before(async () => {81  before(async () => {
150    await usingApi(async (api, privateKeyWrapper) => {82    await usingPlaygrounds(async (helper, privateKey) => {
151      alice = privateKeyWrapper('//Alice');83      donor = privateKey('//Alice');
152      bob = privateKeyWrapper('//Bob');84      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
153    });85    });
154  });86  });
15587
156  it('Burn item in NFT collection', async () => {88  itSub('Burn item in NFT collection', async ({helper}) => {
157    const createMode = 'NFT';89    const collection = await helper.nft.mintCollection(alice);
158    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
159    await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanTransfer: true});90    await collection.setLimits(alice, {ownerCanTransfer: true});
160    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);91    await collection.addAdmin(alice, {Substrate: bob.address});
161    await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);92    const token = await collection.mintToken(alice);
16293
163    await usingApi(async (api) => {94    await token.burnFrom(bob, {Substrate: alice.address});
164      const tx = api.tx.unique.burnFrom(collectionId, {Substrate: alice.address}, tokenId, 1);
165      const events = await submitTransactionAsync(bob, tx);95    expect(await token.doesExist()).to.be.false;
166      const result = getGenericResult(events);
167
168      expect(result.success).to.be.true;
169      // Get the item
170      expect(await isTokenExists(api, collectionId, tokenId)).to.be.false;
171    });
172  });96  });
17397
174  // TODO: burnFrom98  itSub('Burn item in Fungible collection', async ({helper}) => {
175  it('Burn item in Fungible collection', async () => {
176    const createMode = 'Fungible';99    const collection = await helper.ft.mintCollection(alice, {}, 0);
177    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
178    await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanTransfer: true});100    await collection.setLimits(alice, {ownerCanTransfer: true});
179    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode); // Helper creates 10 fungible tokens101    await collection.addAdmin(alice, {Substrate: bob.address});
180    await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);102    await collection.mint(alice, 10n);
181103
182    await usingApi(async (api) => {104    await collection.burnTokensFrom(bob, {Substrate: alice.address}, 1n);
183      // Destroy 1 of 10
184      const tx = api.tx.unique.burnFrom(collectionId, normalizeAccountId(alice.address), tokenId, 1);
185      const events = await submitTransactionAsync(bob, tx);105    expect(await collection.getBalance({Substrate: alice.address})).to.eq(9n);
186      const result = getGenericResult(events);
187
188      // Get alice balance
189      const balance = await getBalance(api, collectionId, alice.address, 0);
190
191      // What to expect
192      expect(result.success).to.be.true;
193      expect(balance).to.be.equal(9n);
194    });
195  });106  });
196107
197  // TODO: burnFrom108  itSub.ifWithPallets('Burn item in ReFungible collection', [Pallets.ReFungible], async function({helper}) {
198  it('Burn item in ReFungible collection', async function() {
199    await requirePallets(this, [Pallets.ReFungible]);109    const collection = await helper.rft.mintCollection(alice);
110    await collection.setLimits(alice, {ownerCanTransfer: true});
111    await collection.addAdmin(alice, {Substrate: bob.address});
112    const token = await collection.mintToken(alice, 100n);
200113
201    const createMode = 'ReFungible';114    await token.burnFrom(bob, {Substrate: alice.address}, 100n);
202    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
203    await setCollectionLimitsExpectSuccess(alice, collectionId, {ownerCanTransfer: true});
204    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);
205    await addCollectionAdminExpectSuccess(alice, collectionId, bob.address);
206
207    await usingApi(async (api) => {
208      const tx = api.tx.unique.burnFrom(collectionId, normalizeAccountId(alice.address), tokenId, 100);
209      const events = await submitTransactionAsync(bob, tx);115    expect(await token.doesExist()).to.be.false;
210      const result = getGenericResult(events);
211      // Get alice balance
212      expect(result.success).to.be.true;
213      // Get the item
214      expect(await isTokenExists(api, collectionId, tokenId)).to.be.false;
215    });
216  });116  });
217});117});
218118
219describe('Negative integration test: ext. burnItem():', () => {119describe('Negative integration test: ext. burnItem():', () => {
120  let donor: IKeyringPair;
121  let alice: IKeyringPair;
122  let bob: IKeyringPair;
123
220  before(async () => {124  before(async () => {
221    await usingApi(async (api, privateKeyWrapper) => {125    await usingPlaygrounds(async (helper, privateKey) => {
222      alice = privateKeyWrapper('//Alice');126      donor = privateKey('//Alice');
223      bob = privateKeyWrapper('//Bob');127      [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor);
224    });128    });
225  });129  });
226130
227  it('Burn a token that was never created', async () => {131  itSub('Burn a token that was never created', async ({helper}) => {
228    const createMode = 'NFT';
229    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
230    const tokenId = 10;
231
232    await usingApi(async (api) => {
233      const tx = api.tx.unique.burnItem(collectionId, tokenId, 1);132    const collection = await helper.nft.mintCollection(alice);
234      const badTransaction = async function () {133    await expect(collection.burnToken(alice, 10)).to.be.rejectedWith('common.TokenNotFound');
235        await submitTransactionExpectFailAsync(alice, tx);
236      };
237      await expect(badTransaction()).to.be.rejected;
238    });
239
240  });134  });
241135
242  it('Burn a token using the address that does not own it', async () => {136  itSub('Burn a token using the address that does not own it', async ({helper}) => {
243    const createMode = 'NFT';137    const collection = await helper.nft.mintCollection(alice);
244    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});
245    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);138    const token = await collection.mintToken(alice);
246139
247    await usingApi(async (api) => {140    await expect(token.burn(bob)).to.be.rejectedWith('common.NoPermission');
248      const tx = api.tx.unique.burnItem(collectionId, tokenId, 1);
249      const badTransaction = async function () {
250        await submitTransactionExpectFailAsync(bob, tx);
251      };
252      await expect(badTransaction()).to.be.rejected;
253    });
254
255  });141  });
256142
257  it('Transfer a burned a token', async () => {143  itSub('Transfer a burned token', async ({helper}) => {
258    const createMode = 'NFT';144    const collection = await helper.nft.mintCollection(alice);
259    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});145    const token = await collection.mintToken(alice);
260    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);146    await token.burn(alice);
261147
262    await usingApi(async (api) => {148    await expect(token.transfer(alice, {Substrate: bob.address})).to.be.rejectedWith('common.TokenNotFound');
263
264      const burntx = api.tx.unique.burnItem(collectionId, tokenId, 1);
265      const events1 = await submitTransactionAsync(alice, burntx);
266      const result1 = getGenericResult(events1);
267      expect(result1.success).to.be.true;
268
269      const tx = api.tx.unique.transfer(normalizeAccountId(bob.address), collectionId, tokenId, 1);
270      const badTransaction = async function () {
271        await submitTransactionExpectFailAsync(alice, tx);
272      };
273      await expect(badTransaction()).to.be.rejected;
274    });
275
276  });149  });
277150
278  it('Burn more than owned in Fungible collection', async () => {151  itSub('Burn more than owned in Fungible collection', async ({helper}) => {
279    const createMode = 'Fungible';152    const collection = await helper.ft.mintCollection(alice, {}, 0);
280    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode, decimalPoints: 0}});
281    // Helper creates 10 fungible tokens153    await collection.mint(alice, 10n);
282    await createItemExpectSuccess(alice, collectionId, createMode);
283    const tokenId = 0; // ignored
284154
285    await usingApi(async (api) => {155    await expect(collection.burnTokens(alice, 11n)).to.be.rejectedWith('common.TokenValueTooLow');
286      // Destroy 11 of 10
287      const tx = api.tx.unique.burnItem(collectionId, tokenId, 11);
288      const badTransaction = async function () {
289        await submitTransactionExpectFailAsync(alice, tx);
290      };
291      await expect(badTransaction()).to.be.rejected;
292
293      // Get alice balance156    expect(await collection.getBalance({Substrate: alice.address})).to.eq(10n);
294      const balance = await getBalance(api, collectionId, alice.address, 0);
295
296      // What to expect
297      expect(balance).to.be.equal(10n);
298    });
299
300  });157  });
301
302});158});
303159

--- a/tests/src/fungible.test.ts
+++ b/tests/src/fungible.test.ts
@@ -101,10 +101,10 @@
     const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
     await collection.mint(alice, 500n);
 
-    expect(await collection.isTokenExists(0)).to.be.true;
+    expect(await collection.doesTokenExist(0)).to.be.true;
     expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
     expect(await collection.burnTokens(alice, 499n)).to.be.true;
-    expect(await collection.isTokenExists(0)).to.be.true;
+    expect(await collection.doesTokenExist(0)).to.be.true;
     expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1n);
   });
   
@@ -112,9 +112,9 @@
     const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
     await collection.mint(alice, 500n);
 
-    expect(await collection.isTokenExists(0)).to.be.true;
+    expect(await collection.doesTokenExist(0)).to.be.true;
     expect(await collection.burnTokens(alice, 500n)).to.be.true;
-    expect(await collection.isTokenExists(0)).to.be.true;
+    expect(await collection.doesTokenExist(0)).to.be.true;
 
     expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(0n);
     expect(await collection.getTotalPieces()).to.be.equal(0n);

--- a/tests/src/refungible.test.ts
+++ b/tests/src/refungible.test.ts
@@ -122,10 +122,10 @@
   itSub('Burn some pieces', async ({helper}) => {
     const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
     const token = await collection.mintToken(alice, 100n);
-    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
+    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
     expect(await token.burn(alice, 99n)).to.be.true;
-    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
+    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(1n);
   });
 
@@ -133,18 +133,18 @@
     const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
     const token = await collection.mintToken(alice, 100n);
     
-    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
+    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
 
     expect(await token.burn(alice, 100n)).to.be.true;
-    expect(await collection.isTokenExists(token.tokenId)).to.be.false;
+    expect(await collection.doesTokenExist(token.tokenId)).to.be.false;
   });
 
   itSub('Burn some pieces for multiple users', async ({helper}) => {
     const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
     const token = await collection.mintToken(alice, 100n);
 
-    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
+    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
     
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
     expect(await token.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
@@ -154,17 +154,17 @@
 
     expect(await token.burn(alice, 40n)).to.be.true;
 
-    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
+    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
     expect(await token.getBalance({Substrate: alice.address})).to.be.equal(0n);
 
     expect(await token.burn(bob, 59n)).to.be.true;
 
     expect(await token.getBalance({Substrate: bob.address})).to.be.equal(1n);
-    expect(await collection.isTokenExists(token.tokenId)).to.be.true;
+    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
 
     expect(await token.burn(bob, 1n)).to.be.true;
 
-    expect(await collection.isTokenExists(token.tokenId)).to.be.false;
+    expect(await collection.doesTokenExist(token.tokenId)).to.be.false;
   });
 
   itSub('Set allowance for token', async ({helper}) => {

--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -1114,10 +1114,10 @@
    *
    * @param collectionId ID of collection
    * @param tokenId ID of token
-   * @example isTokenExists(10, 20);
+   * @example doesTokenExist(10, 20);
    * @returns true if the token exists, otherwise false
    */
-  async isTokenExists(collectionId: number, tokenId: number): Promise<boolean> {
+  async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {
     return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();
   }
 }
@@ -2277,8 +2277,8 @@
     return await this.helper.collection.getLastTokenId(this.collectionId);
   }
 
-  async isTokenExists(tokenId: number) {
-    return await this.helper.collection.isTokenExists(this.collectionId, tokenId);
+  async doesTokenExist(tokenId: number) {
+    return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);
   }
 
   async getAdmins() {
@@ -2607,6 +2607,10 @@
     return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);
   }
 
+  async doesExist() {
+    return await this.collection.doesTokenExist(this.tokenId);
+  }
+
   nestingAccount() {
     return this.collection.helper.util.getTokenAccount(this);
   }