git.delta.rocks / unique-network / refs/commits / 2986834a0c9e

18import {IKeyringPair} from '@polkadot/types/types';18import {IKeyringPair} from '@polkadot/types/types';
19import {19import {
20  createCollectionExpectSuccess,20  createCollectionExpectSuccess,
21  createItemExpectSuccess,
22  transferExpectSuccess,
23  transferExpectFailure,
24  getBalance,21  getBalance,
25  burnItemExpectSuccess,
26  createMultipleItemsExpectSuccess,22  createMultipleItemsExpectSuccess,
27  approveExpectSuccess,
28  transferFromExpectSuccess,
29  isTokenExists,23  isTokenExists,
30  getLastTokenId,24  getLastTokenId,
31  getAllowance,25  getAllowance,
26  approve,
27  transferFrom,
28  createCollection,
29  createRefungibleToken,
30  transfer,
31  burnItem,
32} from './util/helpers';32} from './util/helpers';
3333
34import chai from 'chai';34import chai from 'chai';
47    });47    });
48  });48  });
49
50  it('Create refungible collection and token', async () => {
51    await usingApi(async api => {
52      const createCollectionResult = await createCollection(api, alice, {mode: {type: 'ReFungible'}});
53      expect(createCollectionResult.success).to.be.true;    
54      const collectionId  = createCollectionResult.collectionId;
55
56      const itemCountBefore = await getLastTokenId(api, collectionId);
57      const result = await createRefungibleToken(api, alice, collectionId, 100n);
58
59      const itemCountAfter = await getLastTokenId(api, collectionId);
60
61      // What to expect
62      // tslint:disable-next-line:no-unused-expression
63      expect(result.success).to.be.true;
64      expect(itemCountAfter).to.be.equal(itemCountBefore + 1);
65      expect(collectionId).to.be.equal(result.collectionId);
66      expect(itemCountAfter.toString()).to.be.equal(result.itemId.toString());
67    });
68  });
4969
50  it('Create refungible collection and token. Token pieces transfer.', async () => {70  it('Transfer token pieces', async () => {
51    const createMode = 'ReFungible';71    await usingApi(async api => {
72      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;
52    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});73      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;
74
53    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);75      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);
54
55    let aliceBalance = BigInt(0);76      expect(await transfer(api, collectionId, tokenId, alice, bob, 60n)).to.be.true;
56    await usingApi(async api => {77
57      aliceBalance = await getBalance(api, collectionId, alice.address, tokenId);78      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(40n);
58    });
59    const transferAmount = BigInt(60);
60    await transferExpectSuccess(collectionId, tokenId, alice, bob, transferAmount, 'ReFungible');79      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(60n);
61    aliceBalance = aliceBalance - transferAmount;
62    await transferExpectFailure(collectionId, tokenId, alice, bob, aliceBalance + BigInt(1));80      await expect(transfer(api, collectionId, tokenId, alice, bob, 41n)).to.eventually.be.rejected;
81    });
63  });82  });
6483
65  it('Create multiple tokens', async () => {84  it('Create multiple tokens', async () => {
66    const createMode = 'ReFungible';
67    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});85    const collectionId = await createCollectionExpectSuccess({mode: {type: 'ReFungible'}});
68    const args = [86    const args = [
69      {ReFungible: {pieces: 1}},87      {ReFungible: {pieces: 1}},
70      {ReFungible: {pieces: 2}},88      {ReFungible: {pieces: 2}},
71      {ReFungible: {pieces: 100}},89      {ReFungible: {pieces: 100}},
72    ];90    ];
73    await createMultipleItemsExpectSuccess(alice, collectionId, args);91    await createMultipleItemsExpectSuccess(alice, collectionId, args);
7492
75    let tokenId = 0;
76    await usingApi(async api => {      93    await usingApi(async api => {      
77      tokenId = await getLastTokenId(api, collectionId);94      const tokenId = await getLastTokenId(api, collectionId);
78      expect(tokenId).to.be.equal(3);95      expect(tokenId).to.be.equal(3);
96      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);
79    });97    });
80
81    const transferAmount = BigInt(60);
82    await transferExpectSuccess(collectionId, tokenId, alice, bob, transferAmount, 'ReFungible');
83  });98  });
8499
85  it('Burn some pieces', async () => {100  it('Burn some pieces', async () => {
86    const createMode = 'ReFungible';101    await usingApi(async api => {   
102      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;
87    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});103      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;
88    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);104      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;
89
90    let aliceBalance = BigInt(0);
91    await usingApi(async api => {
92      aliceBalance = await getBalance(api, collectionId, alice.address, tokenId);105      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);
93      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;
94    });
95    await burnItemExpectSuccess(alice, collectionId, tokenId, aliceBalance - BigInt(1));106      expect(await burnItem(api, alice, collectionId, tokenId, 99n)).to.be.true;
96    await usingApi(async api => {
97      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;107      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;
108      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(1n);
98    });109    });
99  });110  });
111
112  it('Burn all pieces', async () => {
113    await usingApi(async api => {   
114      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;
115      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;
116      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;
117      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);
118      expect(await burnItem(api, alice, collectionId, tokenId, 100n)).to.be.true;
119      expect(await isTokenExists(api, collectionId, tokenId)).to.be.false;
120    });
121  });
100122
101  it('Burn all pieces', async () => {123  it('Burn some pieces for multiple users', async () => {
102    const createMode = 'ReFungible';124    await usingApi(async api => {   
125      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;
103    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});126      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;
127      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;
128
129      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);
130      expect(await transfer(api, collectionId, tokenId, alice, bob, 60n)).to.be.true;
131
132      
133      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(40n);
134      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(60n);
104    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);135      expect(await burnItem(api, alice, collectionId, tokenId, 40n)).to.be.true;
105136
137      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(0n);
106    let aliceBalance = BigInt(0);138      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;
107    await usingApi(async api => {139      expect(await burnItem(api, bob, collectionId, tokenId, 59n)).to.be.true;
140
108      aliceBalance = await getBalance(api, collectionId, alice.address, tokenId);141      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(1n);
109      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;142      expect(await isTokenExists(api, collectionId, tokenId)).to.be.true;
110    });
111    await burnItemExpectSuccess(alice, collectionId, tokenId, aliceBalance);143      expect(await burnItem(api, bob, collectionId, tokenId, 1n)).to.be.true;
112    await usingApi(async api => {144      
113      expect(await isTokenExists(api, collectionId, tokenId)).to.be.false;145      expect(await isTokenExists(api, collectionId, tokenId)).to.be.false;
114    });146    });
115  });147  });
116148
117  it('Set allowance for token', async () => {149  it('Set allowance for token', async () => {
118    const createMode = 'ReFungible';150    await usingApi(async api => {
151      const collectionId = (await createCollection(api, alice, {mode: {type: 'ReFungible'}})).collectionId;
119    const collectionId = await createCollectionExpectSuccess({mode: {type: createMode}});152      const tokenId = (await createRefungibleToken(api, alice, collectionId, 100n)).itemId;
153
120    const tokenId = await createItemExpectSuccess(alice, collectionId, createMode);154      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(100n);
121155
122    let aliceBalance = BigInt(0);156      expect(await approve(api, collectionId, tokenId, alice, bob, 60n)).to.be.true;
123    await usingApi(async api => {
124      aliceBalance = await getBalance(api, collectionId, alice.address, tokenId);157      expect(await getAllowance(api, collectionId, alice, bob, tokenId)).to.be.equal(60n);
125    });158
126    const allowedAmount = BigInt(60);
127    await approveExpectSuccess(collectionId, tokenId, alice, bob.address, allowedAmount);159      expect(await transferFrom(api, collectionId, tokenId, bob, alice, bob,  20n)).to.be.true;
128    const transferAmount = BigInt(20);160      expect(await getBalance(api, collectionId, alice, tokenId)).to.be.equal(80n);
129    await transferFromExpectSuccess(collectionId, tokenId, bob, alice, bob,  transferAmount, 'ReFungible');161      expect(await getBalance(api, collectionId, bob, tokenId)).to.be.equal(20n);
130
131    await usingApi(async api => {
132      expect(await getAllowance(api, collectionId, alice.address, bob.address, tokenId)).to.equal(allowedAmount - transferAmount);162      expect(await getAllowance(api, collectionId, alice, bob, tokenId)).to.be.equal(40n);
133    });163    });
134    
135  });164  });
136});165});

--- a/tests/src/util/helpers.ts
+++ b/tests/src/util/helpers.ts
@@ -318,6 +318,33 @@
   tokenPrefix: 'prefix',
 };
 
+export async function
+createCollection(
+  api: ApiPromise,
+  sender: IKeyringPair,
+  params: Partial<CreateCollectionParams> = {},
+): Promise<CreateCollectionResult> {
+  const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};
+
+  let modeprm = {};
+  if (mode.type === 'NFT') {
+    modeprm = {nft: null};
+  } else if (mode.type === 'Fungible') {
+    modeprm = {fungible: mode.decimalPoints};
+  } else if (mode.type === 'ReFungible') {
+    modeprm = {refungible: null};
+  }
+
+  const tx = api.tx.unique.createCollectionEx({
+    name: strToUTF16(name),
+    description: strToUTF16(description),
+    tokenPrefix: strToUTF16(tokenPrefix),
+    mode: modeprm as any,
+  });
+  const events = await submitTransactionAsync(sender, tx);
+  return getCreateCollectionResult(events);
+}
+
 export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {
   const {name, description, mode, tokenPrefix} = {...defaultCreateCollectionParams, ...params};
 
@@ -329,23 +356,7 @@
     // Run the CreateCollection transaction
     const alicePrivateKey = privateKeyWrapper('//Alice');
 
-    let modeprm = {};
-    if (mode.type === 'NFT') {
-      modeprm = {nft: null};
-    } else if (mode.type === 'Fungible') {
-      modeprm = {fungible: mode.decimalPoints};
-    } else if (mode.type === 'ReFungible') {
-      modeprm = {refungible: null};
-    }
-
-    const tx = api.tx.unique.createCollectionEx({
-      name: strToUTF16(name),
-      description: strToUTF16(description),
-      tokenPrefix: strToUTF16(tokenPrefix),
-      mode: modeprm as any,
-    });
-    const events = await submitTransactionAsync(alicePrivateKey, tx);
-    const result = getCreateCollectionResult(events);
+    const result = await createCollection(api, alicePrivateKey, params);
 
     // Get number of collections after the transaction
     const collectionCountAfter = await getCreatedCollectionCount(api);
@@ -490,7 +501,7 @@
   return unused;
 }
 
-export async function getAllowance(api: ApiPromise, collectionId: number, owner: CrossAccountId | string, approved: CrossAccountId | string, tokenId: number) {
+export async function getAllowance(api: ApiPromise, collectionId: number, owner: CrossAccountId | string | IKeyringPair, approved: CrossAccountId | string | IKeyringPair, tokenId: number) {
   return (await api.rpc.unique.allowance(collectionId, normalizeAccountId(owner), normalizeAccountId(approved), tokenId)).toBigInt();
 }
 
@@ -800,16 +811,19 @@
   ReFungible: CreateReFungibleData;
 };
 
+export async function burnItem(api: ApiPromise, sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint) : Promise<boolean> {
+  const tx = api.tx.unique.burnItem(collectionId, tokenId, value);
+  const events = await submitTransactionAsync(sender, tx);
+  return getGenericResult(events).success;
+}
+
 export async function burnItemExpectSuccess(sender: IKeyringPair, collectionId: number, tokenId: number, value: number | bigint = 1) {
   await usingApi(async (api) => {
     const balanceBefore = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);
     // if burning token by admin - use adminButnItemExpectSuccess
     expect(balanceBefore >= BigInt(value)).to.be.true;
 
-    const tx = api.tx.unique.burnItem(collectionId, tokenId, value);
-    const events = await submitTransactionAsync(sender, tx);
-    const result = getGenericResult(events);
-    expect(result.success).to.be.true;
+    expect(await burnItem(api, sender, collectionId, tokenId, value)).to.be.true;
 
     const balanceAfter = await getBalance(api, collectionId, normalizeAccountId(sender), tokenId);
     expect(balanceAfter + BigInt(value)).to.be.equal(balanceBefore);
@@ -817,15 +831,24 @@
 }
 
 export async function
+approve(
+  api: ApiPromise,
+  collectionId: number,
+  tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string | IKeyringPair, amount: number | bigint = 1,
+) {
+  const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);
+  const events = await submitTransactionAsync(owner, approveUniqueTx);
+  return getGenericResult(events).success;
+}
+
+export async function
 approveExpectSuccess(
   collectionId: number,
   tokenId: number, owner: IKeyringPair, approved: CrossAccountId | string, amount: number | bigint = 1,
 ) {
   await usingApi(async (api: ApiPromise) => {
-    const approveUniqueTx = api.tx.unique.approve(normalizeAccountId(approved), collectionId, tokenId, amount);
-    const events = await submitTransactionAsync(owner, approveUniqueTx);
-    const result = getGenericResult(events);
-    expect(result.success).to.be.true;
+    const result  = approve(api, collectionId, tokenId, owner, approved);
+    expect(result).to.be.true;
 
     expect(await getAllowance(api, collectionId, owner.address, approved, tokenId)).to.be.equal(BigInt(amount));
   });
@@ -846,6 +869,23 @@
 }
 
 export async function
+transferFrom(
+  api: ApiPromise,
+  collectionId: number,
+  tokenId: number,
+  accountApproved: IKeyringPair,
+  accountFrom: IKeyringPair | CrossAccountId,
+  accountTo: IKeyringPair | CrossAccountId,
+  value: number | bigint,
+) {
+  const from = normalizeAccountId(accountFrom);
+  const to = normalizeAccountId(accountTo);
+  const transferFromTx = api.tx.unique.transferFrom(from, to, collectionId, tokenId, value);
+  const events = await submitTransactionAsync(accountApproved, transferFromTx);
+  return getGenericResult(events).success;
+}
+
+export async function
 transferFromExpectSuccess(
   collectionId: number,
   tokenId: number,
@@ -862,11 +902,7 @@
     if (type === 'Fungible' || type === 'ReFungible') {
       balanceBefore = await getBalance(api, collectionId, to, tokenId);
     }
-    const transferFromTx = api.tx.unique.transferFrom(normalizeAccountId(accountFrom), to, collectionId, tokenId, value);
-    const events = await submitTransactionAsync(accountApproved, transferFromTx);
-    const result = getGenericResult(events);
-    // tslint:disable-next-line:no-unused-expression
-    expect(result.success).to.be.true;
+    expect(transferFrom(api, collectionId, tokenId, accountApproved, accountFrom, accountTo, value)).to.be.true;
     if (type === 'NFT') {
       expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal(to);
     }
@@ -1071,6 +1107,20 @@
 }
 
 export async function
+transfer(
+  api: ApiPromise,
+  collectionId: number,
+  tokenId: number,
+  sender: IKeyringPair,
+  recipient: IKeyringPair | CrossAccountId,
+  value: number | bigint,
+) : Promise<boolean> {
+  const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);
+  const events = await executeTransaction(api, sender, transferTx);
+  return getGenericResult(events).success;
+}
+
+export async function
 transferExpectSuccess(
   collectionId: number,
   tokenId: number,
@@ -1087,10 +1137,11 @@
     if (type === 'Fungible' || type === 'ReFungible') {
       balanceBefore = await getBalance(api, collectionId, to, tokenId);
     }
-    const transferTx = api.tx.unique.transfer(to, collectionId, tokenId, value);
+
+    const transferTx = api.tx.unique.transfer(normalizeAccountId(recipient), collectionId, tokenId, value);
     const events = await executeTransaction(api, sender, transferTx);
+    const result = getTransferResult(api, events);
 
-    const result = getTransferResult(api, events);
     expect(result.collectionId).to.be.equal(collectionId);
     expect(result.itemId).to.be.equal(tokenId);
     expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));
@@ -1148,7 +1199,7 @@
 export async function getBalance(
   api: ApiPromise,
   collectionId: number,
-  owner: string | CrossAccountId,
+  owner: string | CrossAccountId | IKeyringPair,
   token: number,
 ): Promise<bigint> {
   return (await api.rpc.unique.balance(collectionId, normalizeAccountId(owner), token)).toBigInt();
@@ -1229,7 +1280,7 @@
     const tx = api.tx.unique.createMultipleItems(collectionId, to, itemsData);
 
     const events = await submitTransactionAsync(sender, tx);
-    const result = getCreateItemsResult(events);
+    expect(getGenericResult(events).success).to.be.true;
   });
 }
 
@@ -1366,6 +1417,14 @@
   return newItemId;
 }
 
+export async function createRefungibleToken(api: ApiPromise, sender: IKeyringPair, collectionId: number, amount: bigint, owner: CrossAccountId | IKeyringPair | string = sender.address) : Promise<CreateItemResult> {
+  const createData = {refungible: {pieces: amount}};
+  const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createData as any);
+
+  const events = await submitTransactionAsync(sender, tx);
+  return  getCreateItemResult(events);
+}
+
 export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {
   await usingApi(async (api) => {
     const tx = api.tx.unique.createItem(collectionId, normalizeAccountId(owner), createMode);