git.delta.rocks / unique-network / refs/commits / 994aeb14c5bb

difftreelog

Add checks to mintCross tests

Max Andreev2022-12-21parent: #fce9c8f.patch.diff
in: master

3 files changed

modifiedtests/src/eth/fungible.test.tsdiffbeforeafterboth
--- a/tests/src/eth/fungible.test.ts
+++ b/tests/src/eth/fungible.test.ts
@@ -79,23 +79,40 @@
     expect(event.returnValues.value).to.equal('100');
   });
   
+  [
+    'substrate' as const,
+    'ethereum' as const,
+  ].map(testCase => {
+    itEth(`Can perform mintCross() for ${testCase} address`, async ({helper}) => {
+      // 1. Create receiver depending on the test case:
+      const receiverEth = helper.eth.createAccount();
+      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);
+      const receiverSub = owner;
+      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(owner);
+
+      const ethOwner = await helper.eth.createAccountWithBalance(donor);
+      const collection = await helper.ft.mintCollection(alice);
+      await collection.addAdmin(alice, {Ethereum: ethOwner});
   
-  itEth('Can perform mintCross()', async ({helper}) => {
-    const receiverCross = helper.ethCrossAccount.fromKeyringPair(owner);
-    const ethOwner = await helper.eth.createAccountWithBalance(donor);
-    const collection = await helper.ft.mintCollection(alice);
-    await collection.addAdmin(alice, {Ethereum: ethOwner});
-
-    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', ethOwner);
+      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'ft', ethOwner);
+  
+      // 2. Mint tokens:
+      const result = await collectionEvm.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, 100).send();
+      
+      const event = result.events.Transfer;
+      expect(event.address).to.equal(collectionAddress);
+      expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');
+      expect(event.returnValues.to).to.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(receiverSub.address));
+      expect(event.returnValues.value).to.equal('100');
 
-    const result = await contract.methods.mintCross(receiverCross, 100).send();
-    
-    const event = result.events.Transfer;
-    expect(event.address).to.equal(collectionAddress);
-    expect(event.returnValues.from).to.equal('0x0000000000000000000000000000000000000000');
-    expect(event.returnValues.to).to.equal(helper.address.substrateToEth(owner.address));
-    expect(event.returnValues.value).to.equal('100');
+      // 3. Get balance depending on the test case:
+      let balance;
+      if (testCase === 'ethereum') balance = await collection.getBalance({Ethereum: receiverEth});
+      else if (testCase === 'substrate') balance = await collection.getBalance({Substrate: receiverSub.address});
+      // 3.1 Check balance:
+      expect(balance).to.eq(100n);
+    });
   });
 
   itEth('Can perform mintBulk()', async ({helper}) => {
modifiedtests/src/eth/nonFungible.test.tsdiffbeforeafterboth
175    // expect(tokenUri).to.be.equal(`https://offchain-service.local/token-info/${nextTokenId}`);175    // expect(tokenUri).to.be.equal(`https://offchain-service.local/token-info/${nextTokenId}`);
176  });176  });
177  177  
178  // TODO combine all minting tests in one place
179  [
180    'substrate' as const,
181    'ethereum' as const,
182  ].map(testCase => {
178  itEth('Can perform mintCross()', async ({helper}) => {183    itEth(`Can perform mintCross() for ${testCase} address`, async ({helper}) => {
179    const caller = await helper.eth.createAccountWithBalance(donor);184      const collectionAdmin = await helper.eth.createAccountWithBalance(donor);
185
186      const receiverEth = helper.eth.createAccount();
187      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);
188      const receiverSub = bob;
180    const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);189      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);
190
191      // const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);
181    const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });192      const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });
182    const permissions: ITokenPropertyPermission[] = properties193      const permissions: ITokenPropertyPermission[] = properties
183      .map(p => {194        .map(p => {
195      tokenPrefix: 'ethp',206        tokenPrefix: 'ethp',
196      tokenPropertyPermissions: permissions,207        tokenPropertyPermissions: permissions,
197    });208      });
198    await collection.addAdmin(minter, {Ethereum: caller});209      await collection.addAdmin(minter, {Ethereum: collectionAdmin});
199    210    
200    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);211      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
201    const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', caller, true);212      const contract = helper.ethNativeContract.collection(collectionAddress, 'nft', collectionAdmin, true);
202    let expectedTokenId = await contract.methods.nextTokenId().call();213      let expectedTokenId = await contract.methods.nextTokenId().call();
203    let result = await contract.methods.mintCross(receiverCross, []).send();214      let result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, []).send();
204    let tokenId = result.events.Transfer.returnValues.tokenId;215      let tokenId = result.events.Transfer.returnValues.tokenId;
205    expect(tokenId).to.be.equal(expectedTokenId);216      expect(tokenId).to.be.equal(expectedTokenId);
206217
207    let event = result.events.Transfer;218      let event = result.events.Transfer;
208    expect(event.address).to.be.equal(collectionAddress);219      expect(event.address).to.be.equal(collectionAddress);
209    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');220      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
210    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(bob.address));221      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));
211    expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);222      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
212    223    
213    expectedTokenId = await contract.methods.nextTokenId().call();224      expectedTokenId = await contract.methods.nextTokenId().call();
214    result = await contract.methods.mintCross(receiverCross, properties).send();225      result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, properties).send();
215    event = result.events.Transfer;226      event = result.events.Transfer;
216    expect(event.address).to.be.equal(collectionAddress);227      expect(event.address).to.be.equal(collectionAddress);
217    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');228      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
218    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(bob.address));229      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));
219    expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);230      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
220    231    
221    tokenId = result.events.Transfer.returnValues.tokenId;232      tokenId = result.events.Transfer.returnValues.tokenId;
225    expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties236      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties
226      .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));237        .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));
238      
239      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))
240        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});
227  });241    });
228  242  });
243
244  itEth('Non-owner and non admin cannot mintCross', async ({helper}) => {
245    const nonOwner = await helper.eth.createAccountWithBalance(donor);
246    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
247
248    const collection = await helper.nft.mintCollection(minter);
249    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
250    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft');
251
252    await expect(collectionEvm.methods.mintCross(nonOwnerCross, []).call({from: nonOwner}))
253      .to.be.rejectedWith('PublicMintingNotAllowed');
254  });
255  
229  //TODO: CORE-302 add eth methods256  //TODO: CORE-302 add eth methods
230  itEth.skip('Can perform mintBulk()', async ({helper}) => {257  itEth.skip('Can perform mintBulk()', async ({helper}) => {
modifiedtests/src/eth/reFungible.test.tsdiffbeforeafterboth
--- a/tests/src/eth/reFungible.test.ts
+++ b/tests/src/eth/reFungible.test.ts
@@ -137,48 +137,61 @@
     expect(await contract.methods.tokenURI(tokenId).call()).to.be.equal('Test URI');
   });
   
-  itEth('Can perform mintCross()', async ({helper}) => {
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const receiverCross = helper.ethCrossAccount.fromKeyringPair(bob);
-    const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });
-    const permissions: ITokenPropertyPermission[] = properties.map(p => { return {key: p.key, permission: {tokenOwner: true,
-      collectionAdmin: true,
-      mutable: true}}; });
+  [
+    'substrate' as const,
+    'ethereum' as const,
+  ].map(testCase => {
+    itEth(`Can perform mintCross() for ${testCase} address`, async ({helper}) => {
+      const collectionAdmin = await helper.eth.createAccountWithBalance(donor);
+
+      const receiverEth = helper.eth.createAccount();
+      const receiverCrossEth = helper.ethCrossAccount.fromAddress(receiverEth);
+      const receiverSub = bob;
+      const receiverCrossSub = helper.ethCrossAccount.fromKeyringPair(receiverSub);
+
+      const properties = Array(5).fill(0).map((_, i) => { return {key: `key_${i}`, value: Buffer.from(`value_${i}`)}; });
+      const permissions: ITokenPropertyPermission[] = properties.map(p => { return {key: p.key, permission: {tokenOwner: true,
+        collectionAdmin: true,
+        mutable: true}}; });
     
     
-    const collection = await helper.rft.mintCollection(minter, {
-      tokenPrefix: 'ethp',
-      tokenPropertyPermissions: permissions,
-    });
-    await collection.addAdmin(minter, {Ethereum: caller});
+      const collection = await helper.rft.mintCollection(minter, {
+        tokenPrefix: 'ethp',
+        tokenPropertyPermissions: permissions,
+      });
+      await collection.addAdmin(minter, {Ethereum: collectionAdmin});
     
-    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
-    const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', caller, true);
-    let expectedTokenId = await contract.methods.nextTokenId().call();
-    let result = await contract.methods.mintCross(receiverCross, []).send();
-    let tokenId = result.events.Transfer.returnValues.tokenId;
-    expect(tokenId).to.be.equal(expectedTokenId);
+      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+      const contract = helper.ethNativeContract.collection(collectionAddress, 'rft', collectionAdmin, true);
+      let expectedTokenId = await contract.methods.nextTokenId().call();
+      let result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, []).send();
+      let tokenId = result.events.Transfer.returnValues.tokenId;
+      expect(tokenId).to.be.equal(expectedTokenId);
 
-    let event = result.events.Transfer;
-    expect(event.address).to.be.equal(collectionAddress);
-    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
-    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(bob.address));
-    expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
+      let event = result.events.Transfer;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
+      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));
+      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
     
-    expectedTokenId = await contract.methods.nextTokenId().call();
-    result = await contract.methods.mintCross(receiverCross, properties).send();
-    event = result.events.Transfer;
-    expect(event.address).to.be.equal(collectionAddress);
-    expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
-    expect(event.returnValues.to).to.be.equal(helper.address.substrateToEth(bob.address));
-    expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
+      expectedTokenId = await contract.methods.nextTokenId().call();
+      result = await contract.methods.mintCross(testCase === 'ethereum' ? receiverCrossEth : receiverCrossSub, properties).send();
+      event = result.events.Transfer;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.from).to.be.equal('0x0000000000000000000000000000000000000000');
+      expect(event.returnValues.to).to.be.equal(testCase === 'ethereum' ? receiverEth : helper.address.substrateToEth(bob.address));
+      expect(await contract.methods.properties(tokenId, []).call()).to.be.like([]);
     
-    tokenId = result.events.Transfer.returnValues.tokenId;
+      tokenId = result.events.Transfer.returnValues.tokenId;
 
-    expect(tokenId).to.be.equal(expectedTokenId);
+      expect(tokenId).to.be.equal(expectedTokenId);
     
-    expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties
-      .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));
+      expect(await contract.methods.properties(tokenId, []).call()).to.be.like(properties
+        .map(p => { return helper.ethProperty.property(p.key, p.value.toString()); }));
+
+      expect(await helper.nft.getTokenOwner(collection.collectionId, tokenId))
+        .to.deep.eq(testCase === 'ethereum' ? {Ethereum: receiverEth.toLowerCase()} : {Substrate: receiverSub.address});
+    });
   });
 
   itEth.skip('Can perform mintBulk()', async ({helper}) => {