git.delta.rocks / unique-network / refs/commits / 310b60e05536

2929
30use pallet_nonfungible::erc::{UniqueNFTCall, ERC721UniqueExtensionsCall, ERC721Call};30use pallet_nonfungible::erc::{UniqueNFTCall, ERC721UniqueExtensionsCall, ERC721Call};
31use pallet_fungible::erc::{UniqueFungibleCall, ERC20Call};31use pallet_fungible::erc::{UniqueFungibleCall, ERC20Call};
32use up_data_structs::{CreateItemData, CreateNftData};
3233
33pub struct UniqueEthSponsorshipHandler<T: Config>(PhantomData<*const T>);34pub struct UniqueEthSponsorshipHandler<T: Config>(PhantomData<*const T>);
34impl<T: Config> SponsorshipHandler<T::CrossAccountId, (H160, Vec<u8>)> for UniqueEthSponsorshipHandler<T> {35impl<T: Config> SponsorshipHandler<T::CrossAccountId, (H160, Vec<u8>)> for UniqueEthSponsorshipHandler<T> {
57						withdraw_approve::<T>(&collection, who.as_sub(), &token_id)58						withdraw_approve::<T>(&collection, who.as_sub(), &token_id)
58							.map(|()| sponsor)59							.map(|()| sponsor)
59					}60					}
61					UniqueNFTCall::ERC721Mintable(call) => match call {
62						pallet_nonfungible::erc::ERC721MintableCall::Mint { .. } |
63						pallet_nonfungible::erc::ERC721MintableCall::MintWithTokenUri { .. } => {
64							withdraw_create_item(
65								&collection, 
66								who.as_sub(), 
67								&CreateItemData::NFT(CreateNftData::default()))
68							.map(|()| sponsor)
69						}
70						_ => None,
71    				}
60					_ => None,72					_ => None,
61				}73				}
62			}74			}

--- a/tests/src/eth/contractSponsoring.test.ts
+++ b/tests/src/eth/contractSponsoring.test.ts
@@ -30,16 +30,14 @@
 } from './util/helpers';
 import {
   createCollectionExpectSuccess,
-  createItemExpectSuccess,
   getCreateCollectionResult,
-  normalizeAccountId,
-  toSubstrateAddress,
 } from '../util/helpers';
 import nonFungibleAbi from './nonFungibleAbi.json';
 import {
   submitTransactionAsync,
 } from '../substrate/substrate-api';
-import { evmToAddress } from '@polkadot/util-crypto';
+import getBalance from '../substrate/get-balance';
+import {alicesPublicKey} from '../accounts';
 
 describe('Sponsoring EVM contracts', () => {
   itWeb3('Sponsoring can be set by the address that has deployed the contract', async ({api, web3}) => {
@@ -214,18 +212,10 @@
     const helpers = contractHelpers(web3, owner);
     expect(await helpers.methods.getSponsoringRateLimit(flipper.options.address).call()).to.be.equals('7200');
   });
-
 
-
-
-
-
-
-  
   itWeb3.only('Sponsoring evm address from substrate collection', async ({api, web3}) => {
     const owner = privateKey('//Alice');
     const userEth = createEthAccount(web3);
-    const userSub = evmToAddress(userEth);
     const collectionId = await createCollectionExpectSuccess();
 
     {
@@ -243,31 +233,15 @@
 
     const address = collectionIdToAddress(collectionId);
     const contract = new web3.eth.Contract(nonFungibleAbi as any, address, {from: userEth, ...GAS_ARGS});
-    const receiver = createEthAccount(web3);
 
     { // This part should fail, because user not in access list and user have no money
-      // const nextTokenId = await contract.methods.nextTokenId().call();
-      // expect(nextTokenId).to.be.equal('1');
-      // const result = await contract.methods.mintWithTokenURI(
-      //   receiver,
-      //   nextTokenId,
-      //   'Test URI',
-      // ).send({from: userEth});
-      // const events = normalizeEvents(result.events);
-
-      // expect(events).to.be.deep.equal([
-      //   {
-      //     address,
-      //     event: 'Transfer',
-      //     args: {
-      //       from: '0x0000000000000000000000000000000000000000',
-      //       to: receiver,
-      //       tokenId: nextTokenId,
-      //     },
-      //   },
-      // ]);
-
-      // expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
+      const nextTokenId = await contract.methods.nextTokenId().call();
+      expect(nextTokenId).to.be.equal('1');
+      await expect(contract.methods.mintWithTokenURI(
+        userEth,
+        nextTokenId,
+        'Test URI',
+      ).call({from: userEth})).to.be.rejectedWith(/PublicMintingNotAllowed/);
     }
 
     {
@@ -289,11 +263,13 @@
       expect(result.success).to.be.true;
     }
 
+    const [alicesBalanceBefore] = await getBalance(api, [alicesPublicKey]);
+
     {
       const nextTokenId = await contract.methods.nextTokenId().call();
       expect(nextTokenId).to.be.equal('1');
       const result = await contract.methods.mintWithTokenURI(
-        receiver,
+        userEth,
         nextTokenId,
         'Test URI',
       ).send({from: userEth});
@@ -305,7 +281,7 @@
           event: 'Transfer',
           args: {
             from: '0x0000000000000000000000000000000000000000',
-            to: receiver,
+            to: userEth,
             tokenId: nextTokenId,
           },
         },
@@ -314,5 +290,7 @@
       expect(await contract.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
     }
 
+    const [alicesBalanceAfter] = await getBalance(api, [alicesPublicKey]);
+    expect(alicesBalanceAfter < alicesBalanceBefore).to.be.true;
   });
 });