`27a31c97aaab`

diff tree log

Move burnItemTests to playgrounds

5 files changed

modifiedtests/src/app-promotion.test.tsdiff before after both

34let accounts: IKeyringPair[] = [];34let accounts: IKeyringPair[] = [];
35const LOCKING_PERIOD = 20n; // 20 blocks of relay35const LOCKING_PERIOD = 20n; // 20 blocks of relay
36const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain36const UNLOCKING_PERIOD = 10n; // 10 blocks of parachain
37const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);37const rewardAvailableInBlock = (stakedInBlock: bigint) => {
38  if (stakedInBlock % LOCKING_PERIOD === 0n) return stakedInBlock + 20n;
39  return (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);
40};
3841
39describe('App promotion', () => {42describe('App promotion', () => {
40  before(async function () {43  before(async function () {

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

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

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

101    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});101    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
102    await collection.mint(alice, 500n);102    await collection.mint(alice, 500n);
103103
104    expect(await collection.isTokenExists(0)).to.be.true;104    expect(await collection.doesTokenExist(0)).to.be.true;
105    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);105    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(500n);
106    expect(await collection.burnTokens(alice, 499n)).to.be.true;106    expect(await collection.burnTokens(alice, 499n)).to.be.true;
107    expect(await collection.isTokenExists(0)).to.be.true;107    expect(await collection.doesTokenExist(0)).to.be.true;
108    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1n);108    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(1n);
109  });109  });
110  110  
111  itSub('Burn all tokens ', async ({helper}) => {111  itSub('Burn all tokens ', async ({helper}) => {
112    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});112    const collection = await helper.ft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
113    await collection.mint(alice, 500n);113    await collection.mint(alice, 500n);
114114
115    expect(await collection.isTokenExists(0)).to.be.true;115    expect(await collection.doesTokenExist(0)).to.be.true;
116    expect(await collection.burnTokens(alice, 500n)).to.be.true;116    expect(await collection.burnTokens(alice, 500n)).to.be.true;
117    expect(await collection.isTokenExists(0)).to.be.true;117    expect(await collection.doesTokenExist(0)).to.be.true;
118118
119    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(0n);119    expect(await collection.getBalance({Substrate: alice.address})).to.be.equal(0n);
120    expect(await collection.getTotalPieces()).to.be.equal(0n);120    expect(await collection.getTotalPieces()).to.be.equal(0n);

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

122  itSub('Burn some pieces', async ({helper}) => {122  itSub('Burn some pieces', async ({helper}) => {
123    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});123    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
124    const token = await collection.mintToken(alice, 100n);124    const token = await collection.mintToken(alice, 100n);
125    expect(await collection.isTokenExists(token.tokenId)).to.be.true;125    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
126    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);126    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
127    expect(await token.burn(alice, 99n)).to.be.true;127    expect(await token.burn(alice, 99n)).to.be.true;
128    expect(await collection.isTokenExists(token.tokenId)).to.be.true;128    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
129    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(1n);129    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(1n);
130  });130  });
131131
132  itSub('Burn all pieces', async ({helper}) => {132  itSub('Burn all pieces', async ({helper}) => {
133    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});133    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
134    const token = await collection.mintToken(alice, 100n);134    const token = await collection.mintToken(alice, 100n);
135    135    
136    expect(await collection.isTokenExists(token.tokenId)).to.be.true;136    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
137    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);137    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
138138
139    expect(await token.burn(alice, 100n)).to.be.true;139    expect(await token.burn(alice, 100n)).to.be.true;
140    expect(await collection.isTokenExists(token.tokenId)).to.be.false;140    expect(await collection.doesTokenExist(token.tokenId)).to.be.false;
141  });141  });
142142
143  itSub('Burn some pieces for multiple users', async ({helper}) => {143  itSub('Burn some pieces for multiple users', async ({helper}) => {
144    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});144    const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
145    const token = await collection.mintToken(alice, 100n);145    const token = await collection.mintToken(alice, 100n);
146146
147    expect(await collection.isTokenExists(token.tokenId)).to.be.true;147    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
148    148    
149    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);149    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(100n);
150    expect(await token.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;150    expect(await token.transfer(alice, {Substrate: bob.address}, 60n)).to.be.true;
154154
155    expect(await token.burn(alice, 40n)).to.be.true;155    expect(await token.burn(alice, 40n)).to.be.true;
156156
157    expect(await collection.isTokenExists(token.tokenId)).to.be.true;157    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
158    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(0n);158    expect(await token.getBalance({Substrate: alice.address})).to.be.equal(0n);
159159
160    expect(await token.burn(bob, 59n)).to.be.true;160    expect(await token.burn(bob, 59n)).to.be.true;
161161
162    expect(await token.getBalance({Substrate: bob.address})).to.be.equal(1n);162    expect(await token.getBalance({Substrate: bob.address})).to.be.equal(1n);
163    expect(await collection.isTokenExists(token.tokenId)).to.be.true;163    expect(await collection.doesTokenExist(token.tokenId)).to.be.true;
164164
165    expect(await token.burn(bob, 1n)).to.be.true;165    expect(await token.burn(bob, 1n)).to.be.true;
166166
167    expect(await collection.isTokenExists(token.tokenId)).to.be.false;167    expect(await collection.doesTokenExist(token.tokenId)).to.be.false;
168  });168  });
169169
170  itSub('Set allowance for token', async ({helper}) => {170  itSub('Set allowance for token', async ({helper}) => {

modifiedtests/src/util/playgrounds/unique.tsdiff before after both

1109    return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();1109    return (await this.helper.callRpc('api.rpc.unique.lastTokenId', [collectionId])).toNumber();
1110  }1110  }
11111111
1112  /**1112  /**
1113   * Check if token exists1113   * Check if token exists
1114   *1114   *
1115   * @param collectionId ID of collection1115   * @param collectionId ID of collection
1116   * @param tokenId ID of token1116   * @param tokenId ID of token
1117   * @example isTokenExists(10, 20);1117   * @example doesTokenExist(10, 20);
1118   * @returns true if the token exists, otherwise false1118   * @returns true if the token exists, otherwise false
1119   */1119   */
1120  async isTokenExists(collectionId: number, tokenId: number): Promise<boolean> {1120  async doesTokenExist(collectionId: number, tokenId: number): Promise<boolean> {
1121    return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();1121    return (await this.helper.callRpc('api.rpc.unique.tokenExists', [collectionId, tokenId])).toJSON();
1122  }1122  }
1123}1123}
2277    return await this.helper.collection.getLastTokenId(this.collectionId);2277    return await this.helper.collection.getLastTokenId(this.collectionId);
2278  }2278  }
22792279
2280  async isTokenExists(tokenId: number) {2280  async doesTokenExist(tokenId: number) {
2281    return await this.helper.collection.isTokenExists(this.collectionId, tokenId);2281    return await this.helper.collection.doesTokenExist(this.collectionId, tokenId);
2282  }2282  }
22832283
2284  async getAdmins() {2284  async getAdmins() {
2607    return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);2607    return await this.collection.deleteTokenProperties(signer, this.tokenId, propertyKeys);
2608  }2608  }
2609
2610  async doesExist() {
2611    return await this.collection.doesTokenExist(this.tokenId);
2612  }
26092613
2610  nestingAccount() {2614  nestingAccount() {
2611    return this.collection.helper.util.getTokenAccount(this);2615    return this.collection.helper.util.getTokenAccount(this);