git.delta.rocks / unique-network / refs/commits / 67600317b934

301	}301	}
302302
303	/// @dev Transfer tokens from one address to another303	/// @dev Transfer tokens from one address to another
304	/// @param from address The address which you want to send tokens from304	/// @param from The address which you want to send tokens from
305	/// @param to address The address which you want to transfer to305	/// @param to The address which you want to transfer to
306	/// @param amount uint256 the amount of tokens to be transferred306	/// @param amount the amount of tokens to be transferred
307	#[weight(<CommonWeights<T>>::transfer_from())]307	#[weight(<CommonWeights<T>>::transfer_from())]
308	fn transfer_from_cross(308	fn transfer_from_cross(
309		&mut self,309		&mut self,

163  itEth('Can perform approveCross()', async ({helper}) => {163  itEth('Can perform approveCross()', async ({helper}) => {
164    const owner = await helper.eth.createAccountWithBalance(donor);164    const owner = await helper.eth.createAccountWithBalance(donor);
165    const spender = helper.eth.createAccount();165    const spender = helper.eth.createAccount();
166    const spenderSub = (await helper.arrange.createAccounts([1n], donor))[0];
166    const spenderCross = helper.ethCrossAccount.fromAddress(spender);167    const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);
168    const spenderCrossSub = helper.ethCrossAccount.fromKeyringPair(spenderSub);
169    
167170
168    const collection = await helper.rft.mintCollection(alice);171    const collection = await helper.rft.mintCollection(alice);
172    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);175    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);
173176
174    {177    {
175      const result = await contract.methods.approveCross(spenderCross, 100).send({from: owner});178      const result = await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});
176      const event = result.events.Approval;179      const event = result.events.Approval;
177      expect(event.address).to.be.equal(tokenAddress);180      expect(event.address).to.be.equal(tokenAddress);
178      expect(event.returnValues.owner).to.be.equal(owner);181      expect(event.returnValues.owner).to.be.equal(owner);
186    }189    }
190    
191    
192    {
193      const result = await contract.methods.approveCross(spenderCrossSub, 100).send({from: owner});
194      const event = result.events.Approval;
195      expect(event.address).to.be.equal(tokenAddress);
196      expect(event.returnValues.owner).to.be.equal(owner);
197      expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(spenderSub.address));
198      expect(event.returnValues.value).to.be.equal('100');
199    }
200
201    {
202      const allowance = await collection.getTokenApprovedPieces(tokenId, {Ethereum: owner}, {Substrate: spenderSub.address});
203      expect(allowance).to.equal(100n);
204    }
205  
206    {
207      //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call()
208    }
187  });209  });
188  210  
189  itEth('Can perform transferFrom()', async ({helper}) => {211  itEth('Can perform transferFrom()', async ({helper}) => {
229    const ownerCross = helper.ethCrossAccount.fromAddress(owner);251    const ownerCross = helper.ethCrossAccount.fromAddress(owner);
230    const spender = await helper.eth.createAccountWithBalance(donor);252    const spender = await helper.eth.createAccountWithBalance(donor);
231    const receiver = helper.eth.createAccount();253    const receiver = helper.eth.createAccount();
254    const receiverSub = (await helper.arrange.createAccounts([1n], donor))[0];
232    const receiverCross = helper.ethCrossAccount.fromAddress(receiver);255    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiver);
256    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);
257    
233    const collection = await helper.rft.mintCollection(alice);258    const collection = await helper.rft.mintCollection(alice);
234    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});259    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});
235260
236    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);261    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);
237    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);262    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);
238263
239    await contract.methods.approve(spender, 100).send();264    await contract.methods.approve(spender, 100).send({from: owner});
240265    
241    {266    {
242      const result = await contract.methods.transferFromCross(ownerCross, receiverCross, 49).send({from: spender});267      const result = await contract.methods.transferFromCross(ownerCross, receiverCrossEth, 49).send({from: spender});
243      let event = result.events.Transfer;268      let event = result.events.Transfer;
244      expect(event.address).to.be.equal(tokenAddress);269      expect(event.address).to.be.equal(tokenAddress);
245      expect(event.returnValues.from).to.be.equal(owner);270      expect(event.returnValues.from).to.be.equal(owner);
263      expect(+balance).to.equal(151);288      expect(+balance).to.equal(151);
264    }289    }
290    
291    {
292      const result = await contract.methods.transferFromCross(ownerCross, receiverCrossSub, 51).send({from: spender});
293      let event = result.events.Transfer;
294      expect(event.address).to.be.equal(tokenAddress);
295      expect(event.returnValues.from).to.be.equal(owner);
296      expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));
297      expect(event.returnValues.value).to.be.equal('51');
298
299      event = result.events.Approval;
300      expect(event.address).to.be.equal(tokenAddress);
301      expect(event.returnValues.owner).to.be.equal(owner);
302      expect(event.returnValues.spender).to.be.equal(spender);
303      expect(event.returnValues.value).to.be.equal('0');
304    }
305
306    {
307      const balance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});
308      expect(balance).to.equal(51n);
309    }
310
311    {
312      const balance = await contract.methods.balanceOf(owner).call();
313      expect(+balance).to.equal(100);
314    }
265  });315  });
266316
267  itEth('Can perform transfer()', async ({helper}) => {317  itEth('Can perform transfer()', async ({helper}) => {
336  itEth('Can perform transferCross()', async ({helper}) => {386  itEth('Can perform transferCross()', async ({helper}) => {
337    const owner = await helper.eth.createAccountWithBalance(donor);387    const owner = await helper.eth.createAccountWithBalance(donor);
338    const receiver = helper.eth.createAccount();388    const receiver = helper.eth.createAccount();
389    const receiverSub = (await helper.arrange.createAccounts([1n], donor))[0];
339    const receiverCross = helper.ethCrossAccount.fromAddress(receiver);390    const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiver);
391    const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);
340    const collection = await helper.rft.mintCollection(alice);392    const collection = await helper.rft.mintCollection(alice);
341    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});393    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});
342394
343    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);395    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);
344    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);396    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);
345397
346    {398    {
347      const result = await contract.methods.transferCross(receiverCross, 50).send({from: owner});399      const result = await contract.methods.transferCross(receiverCrossEth, 50).send({from: owner});
348      const event = result.events.Transfer;400      const event = result.events.Transfer;
349      expect(event.address).to.be.equal(tokenAddress);401      expect(event.address).to.be.equal(tokenAddress);
350      expect(event.returnValues.from).to.be.equal(owner);402      expect(event.returnValues.from).to.be.equal(owner);
362      expect(+balance).to.equal(50);414      expect(+balance).to.equal(50);
363    }415    }
416    
417    {
418      const result = await contract.methods.transferCross(receiverCrossSub, 50).send({from: owner});
419      const event = result.events.Transfer;
420      expect(event.address).to.be.equal(tokenAddress);
421      expect(event.returnValues.from).to.be.equal(owner);
422      expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(receiverSub.address));
423      expect(event.returnValues.value).to.be.equal('50');
424    }
425
426    {
427      const balance = await contract.methods.balanceOf(owner).call();
428      expect(+balance).to.equal(100);
429    }
430
431    {
432      const balance = await collection.getTokenBalance(tokenId, {Substrate: receiverSub.address});
433      expect(balance).to.equal(50n);
434    }
364  });435  });
365  itEth('Can perform repartition()', async ({helper}) => {436  itEth('Can perform repartition()', async ({helper}) => {
366    const owner = await helper.eth.createAccountWithBalance(donor);437    const owner = await helper.eth.createAccountWithBalance(donor);
451  522  
452  itEth('Can perform burnFromCross()', async ({helper}) => {523  itEth('Can perform burnFromCross()', async ({helper}) => {
453    const owner = await helper.eth.createAccountWithBalance(donor);524    const owner = await helper.eth.createAccountWithBalance(donor);
525    const ownerSub = (await helper.arrange.createAccounts([10n], donor))[0];
454    const ownerCross = helper.ethCrossAccount.fromAddress(owner);526    const ownerCross = helper.ethCrossAccount.fromAddress(owner);
455    const spender = await helper.eth.createAccountWithBalance(donor);527    const spender = await helper.eth.createAccountWithBalance(donor);
528   
456    const spenderCross = helper.ethCrossAccount.fromAddress(spender);529    const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);
530    const ownerSubCross = helper.ethCrossAccount.fromKeyringPair(ownerSub);
457531
458    const collection = await helper.rft.mintCollection(alice);532    const collection = await helper.rft.mintCollection(alice);
459    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});533    const {tokenId} = await collection.mintToken(alice, 200n, {Ethereum: owner});
534    
460535
461    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);536    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);
462    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);537    const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);
463538
539    {
464    await contract.methods.approveCross(spenderCross, 100).send({from: owner});540      await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});
465    541    
466    await expect(contract.methods.burnFromCross(ownerCross, 50).send({from: spender})).to.be.fulfilled;542      await expect(contract.methods.burnFromCross(ownerCross, 50).send({from: spender})).to.be.fulfilled;
467    await expect(contract.methods.burnFromCross(ownerCross, 100).send({from: spender})).to.be.rejected;543      await expect(contract.methods.burnFromCross(ownerCross, 100).send({from: spender})).to.be.rejected;
468    expect(await contract.methods.balanceOf(owner).call({from: owner})).to.be.equal('150');544      expect(await contract.methods.balanceOf(owner).call({from: owner})).to.be.equal('150');
545    }
546    {
547      const {tokenId} = await collection.mintToken(alice, 200n, {Substrate: ownerSub.address});
548      await collection.approveToken(ownerSub, tokenId, {Ethereum: spender}, 100n);
549      const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, tokenId);
550      const contract = helper.ethNativeContract.rftToken(tokenAddress, owner);
551    
552      await expect(contract.methods.burnFromCross(ownerSubCross, 50).send({from: spender})).to.be.fulfilled;
553      await expect(contract.methods.burnFromCross(ownerSubCross, 100).send({from: spender})).to.be.rejected;
554      expect(await collection.getTokenBalance(tokenId, {Substrate: ownerSub.address})).to.be.equal(150n);
555    }
469  });556  });
470});557});
471558