git.delta.rocks / unique-network / refs/commits / 3e8db543c726

--- a/.env
+++ b/.env
@@ -3,21 +3,21 @@
 
 POLKADOT_MAINNET_BRANCH=release-v0.9.30
 STATEMINT_BUILD_BRANCH=release-parachains-v9320
-ACALA_BUILD_BRANCH=2.10.1
+ACALA_BUILD_BRANCH=2.11.0
 MOONBEAM_BUILD_BRANCH=runtime-1901
-UNIQUE_MAINNET_BRANCH=v930033
+UNIQUE_MAINNET_BRANCH=release-v930033
 UNIQUE_REPLICA_FROM=wss://eu-ws.unique.network:443
 
-KUSAMA_MAINNET_BRANCH=release-v0.9.34
-STATEMINE_BUILD_BRANCH=release-parachains-v9320
-KARURA_BUILD_BRANCH=release-karura-2.10.0
-MOONRIVER_BUILD_BRANCH=runtime-1901
-QUARTZ_MAINNET_BRANCH=v930033
+KUSAMA_MAINNET_BRANCH=release-v0.9.35
+STATEMINE_BUILD_BRANCH=release-parachains-v9330
+KARURA_BUILD_BRANCH=release-karura-2.11.0
+MOONRIVER_BUILD_BRANCH=runtime-2000
+QUARTZ_MAINNET_BRANCH=release-v930034
 QUARTZ_REPLICA_FROM=wss://eu-ws-quartz.unique.network:443
 
 UNQWND_MAINNET_BRANCH=release-v0.9.30
 WESTMINT_BUILD_BRANCH=parachains-v9330
-OPAL_MAINNET_BRANCH=v930032
+OPAL_MAINNET_BRANCH=release-v930034
 OPAL_REPLICA_FROM=wss://eu-ws-opal.unique.network:443
 
 POLKADOT_LAUNCH_BRANCH=unique-network

--- a/tests/package.json
+++ b/tests/package.json
@@ -8,11 +8,13 @@
     "@types/chai": "^4.3.3",
     "@types/chai-as-promised": "^7.1.5",
     "@types/chai-like": "^1.1.1",
+    "@types/chai-subset": "^1.3.3",
     "@types/mocha": "^10.0.0",
     "@types/node": "^18.11.2",
     "@typescript-eslint/eslint-plugin": "^5.40.1",
     "@typescript-eslint/parser": "^5.40.1",
     "chai": "^4.3.6",
+    "chai-subset": "^1.6.0",
     "eslint": "^8.25.0",
     "eslint-plugin-mocha": "^10.1.0",
     "mocha": "^10.1.0",

--- a/tests/src/eth/collectionAdmin.test.ts
+++ b/tests/src/eth/collectionAdmin.test.ts
@@ -15,6 +15,7 @@
 
 import {IKeyringPair} from '@polkadot/types/types';
 import {expect} from 'chai';
+import {Pallets} from '../util';
 import {IEthCrossAccountId} from '../util/playgrounds/types';
 import {usingEthPlaygrounds, itEth} from './util';
 import {EthUniqueHelper} from './util/playgrounds/unique.dev';
@@ -39,36 +40,52 @@
     });
   });
 
-  itEth('can add account admin by owner', async ({helper, privateKey}) => {
-    // arrange
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const adminSub = await privateKey('//admin2');
-    const adminEth = helper.eth.createAccount().toLowerCase();
-
-    const adminDeprecated = helper.eth.createAccount().toLowerCase();
-    const adminCrossSub = helper.ethCrossAccount.fromKeyringPair(adminSub);
-    const adminCrossEth = helper.ethCrossAccount.fromAddress(adminEth);
-        
-    const {collectionAddress, collectionId} = await helper.eth.createNFTCollection(owner, 'A', 'B', 'C');
-    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft', owner, true);
-
-    // Soft-deprecated: can addCollectionAdmin 
-    await collectionEvm.methods.addCollectionAdmin(adminDeprecated).send();
-    // Can addCollectionAdminCross for substrate and ethereum address
-    await collectionEvm.methods.addCollectionAdminCross(adminCrossSub).send();
-    await collectionEvm.methods.addCollectionAdminCross(adminCrossEth).send();
+  [
+    {mode: 'nft' as const, requiredPallets: []},
+    {mode: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
+    {mode: 'ft' as const, requiredPallets: []},
+  ].map(testCase => {
+    itEth.ifWithPallets(`can add account admin by owner for ${testCase.mode}`, testCase.requiredPallets, async ({helper, privateKey}) => {
+      // arrange
+      const owner = await helper.eth.createAccountWithBalance(donor);
+      const adminSub = await privateKey('//admin2');
+      const adminEth = helper.eth.createAccount().toLowerCase();
+  
+      const adminDeprecated = helper.eth.createAccount().toLowerCase();
+      const adminCrossSub = helper.ethCrossAccount.fromKeyringPair(adminSub);
+      const adminCrossEth = helper.ethCrossAccount.fromAddress(adminEth);
+      
+      const {collectionAddress, collectionId} = await helper.eth.createCollection(testCase.mode, owner, 'A', 'B', 'C');
+      const collectionEvm = helper.ethNativeContract.collection(collectionAddress, testCase.mode, owner, true);
 
-    // 1. Expect api.rpc.unique.adminlist returns admins:
-    const adminListRpc = await helper.collection.getAdmins(collectionId);
-    expect(adminListRpc).to.has.length(3);
-    expect(adminListRpc).to.be.deep.contain.members([{Substrate: adminSub.address}, {Ethereum: adminEth}, {Ethereum: adminDeprecated}]);
+      // Check isOwnerOrAdminCross returns false:
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(adminCrossSub).call()).to.be.false;
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(adminCrossEth).call()).to.be.false;
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(helper.ethCrossAccount.fromAddress(adminDeprecated)).call()).to.be.false;
+      
+      // Soft-deprecated: can addCollectionAdmin 
+      await collectionEvm.methods.addCollectionAdmin(adminDeprecated).send();
+      // Can addCollectionAdminCross for substrate and ethereum address
+      await collectionEvm.methods.addCollectionAdminCross(adminCrossSub).send();
+      await collectionEvm.methods.addCollectionAdminCross(adminCrossEth).send();
+  
+      // 1. Expect api.rpc.unique.adminlist returns admins:
+      const adminListRpc = await helper.collection.getAdmins(collectionId);
+      expect(adminListRpc).to.has.length(3);
+      expect(adminListRpc).to.be.deep.contain.members([{Substrate: adminSub.address}, {Ethereum: adminEth}, {Ethereum: adminDeprecated}]);
+  
+      // 2. Expect methods.collectionAdmins == api.rpc.unique.adminlist
+      let adminListEth = await collectionEvm.methods.collectionAdmins().call();
+      adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
+        return helper.address.convertCrossAccountFromEthCrossAccount(element);
+      });
+      expect(adminListRpc).to.be.like(adminListEth);
 
-    // 2. Expect methods.collectionAdmins == api.rpc.unique.adminlist
-    let adminListEth = await collectionEvm.methods.collectionAdmins().call();
-    adminListEth = adminListEth.map((element: IEthCrossAccountId) => {
-      return helper.address.convertCrossAccountFromEthCrossAccount(element);
+      // 3. check isOwnerOrAdminCross returns true:
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(adminCrossSub).call()).to.be.true;
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(adminCrossEth).call()).to.be.true;
+      expect(await collectionEvm.methods.isOwnerOrAdminCross(helper.ethCrossAccount.fromAddress(adminDeprecated)).call()).to.be.true;
     });
-    expect(adminListRpc).to.be.like(adminListEth);
   });
 
   itEth('cross account admin can mint', async ({helper}) => {

--- a/tests/src/eth/collectionProperties.test.ts
+++ b/tests/src/eth/collectionProperties.test.ts
@@ -26,27 +26,36 @@
   before(async function() {
     await usingEthPlaygrounds(async (_helper, privateKey) => {
       donor = await privateKey({filename: __filename});
-      [alice] = await _helper.arrange.createAccounts([20n], donor);
+      [alice] = await _helper.arrange.createAccounts([50n], donor);
     });
   });
 
   // Soft-deprecated: setCollectionProperty
   [
-    {method: 'setCollectionProperties', methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]], expectedProps: [{key: 'testKey1', value: 'testValue1'}, {key: 'testKey2', value: 'testValue2'}]}, 
-    {method: 'setCollectionProperty', methodParams: ['testKey', Buffer.from('testValue')], expectedProps: [{key: 'testKey', value: 'testValue'}]},
+    {method: 'setCollectionProperties', mode: 'nft' as const, methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]], expectedProps: [{key: 'testKey1', value: 'testValue1'}, {key: 'testKey2', value: 'testValue2'}]}, 
+    {method: 'setCollectionProperties', mode: 'rft' as const, methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]], expectedProps: [{key: 'testKey1', value: 'testValue1'}, {key: 'testKey2', value: 'testValue2'}]}, 
+    {method: 'setCollectionProperties', mode: 'ft' as const, methodParams: [[{key: 'testKey1', value: Buffer.from('testValue1')}, {key: 'testKey2', value: Buffer.from('testValue2')}]], expectedProps: [{key: 'testKey1', value: 'testValue1'}, {key: 'testKey2', value: 'testValue2'}]}, 
+    {method: 'setCollectionProperty', mode: 'nft' as const, methodParams: ['testKey', Buffer.from('testValue')], expectedProps: [{key: 'testKey', value: 'testValue'}]},
   ].map(testCase => 
-    itEth(`Collection properties can be set: ${testCase.method}`, async({helper}) => {
+    itEth.ifWithPallets(`Collection properties can be set: ${testCase.method}() for ${testCase.mode}`, testCase.mode === 'rft' ? [Pallets.ReFungible] : [], async({helper}) => {
       const caller = await helper.eth.createAccountWithBalance(donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties: []});
+      const collection = await helper[testCase.mode].mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties: []});
       await collection.addAdmin(alice, {Ethereum: caller});
-
+      
       const address = helper.ethAddress.fromCollectionId(collection.collectionId);
-      const contract = helper.ethNativeContract.collection(address, 'nft', caller, testCase.method === 'setCollectionProperty');
+      const collectionEvm = helper.ethNativeContract.collection(address, 'nft', caller, testCase.method === 'setCollectionProperty');
 
-      await contract.methods[testCase.method](...testCase.methodParams).send({from: caller});
+      // collectionProperties returns an empty array if no properties: 
+      expect(await collectionEvm.methods.collectionProperties([]).call()).to.be.like([]);
+      expect(await collectionEvm.methods.collectionProperties(['NonExistingKey']).call()).to.be.like([]);
+
+      await collectionEvm.methods[testCase.method](...testCase.methodParams).send({from: caller});
 
       const raw = (await collection.getData())?.raw;
       expect(raw.properties).to.deep.equal(testCase.expectedProps);
+
+      // collectionProperties returns properties: 
+      expect(await collectionEvm.methods.collectionProperties([]).call()).to.be.like(testCase.expectedProps.map(prop => helper.ethProperty.property(prop.key, prop.value)));
     }));
 
   itEth('Cannot set invalid properties', async({helper}) => {
@@ -68,16 +77,18 @@
 
   // Soft-deprecated: deleteCollectionProperty
   [
-    {method: 'deleteCollectionProperties', methodParams: [['testKey1', 'testKey2']], expectedProps: [{key: 'testKey3', value: 'testValue3'}]},
-    {method: 'deleteCollectionProperty', methodParams: ['testKey1'], expectedProps: [{key: 'testKey2', value: 'testValue2'}, {key: 'testKey3', value: 'testValue3'}]}, 
+    {method: 'deleteCollectionProperties', mode: 'nft' as const, methodParams: [['testKey1', 'testKey2']], expectedProps: [{key: 'testKey3', value: 'testValue3'}]},
+    {method: 'deleteCollectionProperties', mode: 'rft' as const, methodParams: [['testKey1', 'testKey2']], expectedProps: [{key: 'testKey3', value: 'testValue3'}]},
+    {method: 'deleteCollectionProperties', mode: 'ft' as const, methodParams: [['testKey1', 'testKey2']], expectedProps: [{key: 'testKey3', value: 'testValue3'}]},
+    {method: 'deleteCollectionProperty', mode: 'nft' as const, methodParams: ['testKey1'], expectedProps: [{key: 'testKey2', value: 'testValue2'}, {key: 'testKey3', value: 'testValue3'}]}, 
   ].map(testCase => 
-    itEth(`Collection properties can be deleted: ${testCase.method}()`, async({helper}) => {
+    itEth.ifWithPallets(`Collection properties can be deleted: ${testCase.method}() for ${testCase.mode}`, testCase.mode === 'rft' ? [Pallets.ReFungible] : [], async({helper}) => {
       const properties = [
         {key: 'testKey1', value: 'testValue1'},
         {key: 'testKey2', value: 'testValue2'},
         {key: 'testKey3', value: 'testValue3'}];
       const caller = await helper.eth.createAccountWithBalance(donor);
-      const collection = await helper.nft.mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties});
+      const collection = await helper[testCase.mode].mintCollection(alice, {name: 'name', description: 'test', tokenPrefix: 'test', properties});
   
       await collection.addAdmin(alice, {Ethereum: caller});
   
@@ -92,7 +103,6 @@
       expect(raw.properties).to.deep.equal(testCase.expectedProps);
     }));
 
-  
   [
     {method: 'deleteCollectionProperties', methodParams: [['testKey2']]},
     {method: 'deleteCollectionProperty', methodParams: ['testKey2']},
@@ -207,82 +217,5 @@
   
       await contract.methods.setProperties(tokenId2, [{key: 'URISuffix', value: Buffer.from(SUFFIX)}]).send();
       expect(await contract.methods.tokenURI(tokenId2).call()).to.equal(BASE_URI + SUFFIX);
-    }));
-});
-
-describe('EVM collection property', () => {
-  let donor: IKeyringPair;
-
-  before(async function() {
-    await usingEthPlaygrounds(async (_helper, privateKey) => {
-      donor = await privateKey({filename: __filename});
-    });
-  });
-
-  [
-    {case: 'nft' as const},
-    {case: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
-    {case: 'ft' as const},
-  ].map(testCase => 
-    itEth.ifWithPallets(`can set/read properties ${testCase.case}`, testCase.requiredPallets || [], async ({helper}) => {
-      const collection = await helper[testCase.case].mintCollection(donor, {name: 'A', description: 'B', tokenPrefix: 'C'});
-
-      const sender = await helper.eth.createAccountWithBalance(donor, 100n);
-      await collection.addAdmin(donor, {Ethereum: sender});
-  
-      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
-      const contract = helper.ethNativeContract.collection(collectionAddress, testCase.case, sender);
-  
-      const keys = ['key0', 'key1'];
-  
-      const writeProperties = [
-        helper.ethProperty.property(keys[0], 'value0'),
-        helper.ethProperty.property(keys[1], 'value1'),
-      ];
-  
-      await contract.methods.setCollectionProperties(writeProperties).send();
-      const readProperties = await contract.methods.collectionProperties([keys[0], keys[1]]).call();
-      expect(readProperties).to.be.like(writeProperties);
-    }));
-
-  [
-    {case: 'nft' as const},
-    {case: 'rft' as const, requiredPallets: [Pallets.ReFungible]},
-    {case: 'ft' as const},
-  ].map(testCase => 
-    itEth.ifWithPallets(`can delete properties ${testCase.case}`, testCase.requiredPallets || [], async ({helper}) => {
-      const collection = await helper[testCase.case].mintCollection(donor, {name: 'A', description: 'B', tokenPrefix: 'C'});
-
-      const sender = await helper.eth.createAccountWithBalance(donor, 100n);
-      await collection.addAdmin(donor, {Ethereum: sender});
-  
-      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
-      const contract = helper.ethNativeContract.collection(collectionAddress, testCase.case, sender);
-  
-      const keys = ['key0', 'key1', 'key2', 'key3'];
-  
-      {
-        const writeProperties = [
-          helper.ethProperty.property(keys[0], 'value0'),
-          helper.ethProperty.property(keys[1], 'value1'),
-          helper.ethProperty.property(keys[2], 'value2'),
-          helper.ethProperty.property(keys[3], 'value3'),
-        ];
-  
-        await contract.methods.setCollectionProperties(writeProperties).send();
-        const readProperties = await contract.methods.collectionProperties([keys[0], keys[1], keys[2], keys[3]]).call();
-        expect(readProperties).to.be.like(writeProperties);
-      }
-  
-      {
-        const expectProperties = [
-          helper.ethProperty.property(keys[0], 'value0'),
-          helper.ethProperty.property(keys[1], 'value1'),
-        ];
-  
-        await contract.methods.deleteCollectionProperties([keys[2], keys[3]]).send();
-        const readProperties = await contract.methods.collectionProperties([]).call();
-        expect(readProperties).to.be.like(expectProperties);
-      }
     }));
 });

--- a/tests/src/eth/contractSponsoring.test.ts
+++ b/tests/src/eth/contractSponsoring.test.ts
@@ -22,29 +22,31 @@
 
 describe('Sponsoring EVM contracts', () => {
   let donor: IKeyringPair;
+  let nominal: bigint;
 
   before(async () => {
-    await usingPlaygrounds(async (_helper, privateKey) => {
+    await usingPlaygrounds(async (helper, privateKey) => {
       donor = await privateKey({filename: __filename});
+      nominal = helper.balance.getOneTokenNominal();
     });
   });
 
-  itEth('Self sponsored can be set by the address that deployed the contract', async ({helper}) => {
+  itEth('Self sponsoring can be set by the address that deployed the contract', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const flipper = await helper.eth.deployFlipper(owner);
     const helpers = helper.ethNativeContract.contractHelpers(owner);
 
+    // 1. owner can set selfSponsoring:
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
-    await expect(helpers.methods.selfSponsoredEnable(flipper.options.address).send()).to.be.not.rejected;
+    const result = await helpers.methods.selfSponsoredEnable(flipper.options.address).send({from: owner});
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
-  });
 
-  itEth('Set self sponsored events', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const flipper = await helper.eth.deployFlipper(owner);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    
-    const result = await helpers.methods.selfSponsoredEnable(flipper.options.address).send();
+    // 1.1 Can get sponsor using methods.sponsor:
+    const actualSponsor = await helpers.methods.sponsor(flipper.options.address).call();
+    expect(actualSponsor.eth).to.eq(flipper.options.address);
+    expect(actualSponsor.sub).to.eq('0');
+
+    // 2. Events should be:
     const ethEvents = helper.eth.helper.eth.normalizeEvents(result.events);
     expect(ethEvents).to.be.deep.equal([
       {
@@ -66,7 +68,7 @@
     ]);
   });
 
-  itEth('Self sponsored can not be set by the address that did not deployed the contract', async ({helper}) => {
+  itEth('Self sponsoring cannot be set by the address that did not deployed the contract', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const notOwner = await helper.eth.createAccountWithBalance(donor);
     const helpers = helper.ethNativeContract.contractHelpers(owner);
@@ -83,7 +85,7 @@
     const flipper = await helper.eth.deployFlipper(owner);
 
     expect(await helpers.methods.sponsoringEnabled(flipper.options.address).call()).to.be.false;
-    await expect(helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner})).to.be.not.rejected;
+    await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
     expect(await helpers.methods.sponsoringEnabled(flipper.options.address).call()).to.be.true;
   });
 
@@ -104,18 +106,12 @@
     const helpers = helper.ethNativeContract.contractHelpers(owner);
     const flipper = await helper.eth.deployFlipper(owner);
 
+    // 1. owner can set a sponsor:
     expect(await helpers.methods.hasPendingSponsor(flipper.options.address).call()).to.be.false;
-    await expect(helpers.methods.setSponsor(flipper.options.address, sponsor).send()).to.be.not.rejected;
-    expect(await helpers.methods.hasPendingSponsor(flipper.options.address).call()).to.be.true;
-  });
-  
-  itEth('Set sponsor event', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-    
     const result = await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
+    expect(await helpers.methods.hasPendingSponsor(flipper.options.address).call()).to.be.true;
+
+    // 2. Events should be:
     const events = helper.eth.normalizeEvents(result.events);
     expect(events).to.be.deep.equal([
       {
@@ -129,7 +125,7 @@
     ]);
   });
   
-  itEth('Sponsor can not be set by the address that did not deployed the contract', async ({helper}) => {
+  itEth('Sponsor cannot be set by the address that did not deployed the contract', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
     const sponsor = await helper.eth.createAccountWithBalance(donor);
     const notOwner = await helper.eth.createAccountWithBalance(donor);
@@ -148,19 +144,18 @@
     const flipper = await helper.eth.deployFlipper(owner);
 
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
-    await expect(helpers.methods.setSponsor(flipper.options.address, sponsor).send()).to.be.not.rejected;
-    await expect(helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor})).to.be.not.rejected;
+    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
+
+    // 1. sponsor can confirm sponsorship:
+    const result = await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
-  });
 
-  itEth('Confirm sponsorship event', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
+    // 1.1 Can get sponsor using methods.sponsor:
+    const actualSponsor = await helpers.methods.sponsor(flipper.options.address).call();
+    expect(actualSponsor.eth).to.eq(sponsor);
+    expect(actualSponsor.sub).to.eq('0');
 
-    await expect(helpers.methods.setSponsor(flipper.options.address, sponsor).send()).to.be.not.rejected;
-    const result = await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
+    // 2. Events should be:
     const events = helper.eth.normalizeEvents(result.events);
     expect(events).to.be.deep.equal([
       {
@@ -196,34 +191,6 @@
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
     await expect(helpers.methods.confirmSponsorship(flipper.options.address).call({from: notSponsor})).to.be.rejectedWith('NoPendingSponsor');
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
-  });
-
-  itEth('Get self sponsored sponsor', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.selfSponsoredEnable(flipper.options.address).send();
-    
-    const result = await helpers.methods.sponsor(flipper.options.address).call();
-
-    expect(result[0]).to.be.eq(flipper.options.address);
-    expect(result[1]).to.be.eq('0');
-  });
-
-  itEth('Get confirmed sponsor', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
-    await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
-    
-    const result = await helpers.methods.sponsor(flipper.options.address).call();
-
-    expect(result[0]).to.be.eq(sponsor);
-    expect(result[1]).to.be.eq('0');
   });
 
   itEth('Sponsor can be removed by the address that deployed the contract', async ({helper}) => {
@@ -236,21 +203,11 @@
     await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
     await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
-    
-    await helpers.methods.removeSponsor(flipper.options.address).send();
+    // 1. Can remove sponsor:
+    const result = await helpers.methods.removeSponsor(flipper.options.address).send();
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.false;
-  });
 
-  itEth('Remove sponsor event', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
-    await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
-    
-    const result = await helpers.methods.removeSponsor(flipper.options.address).send();
+    // 2. Events should be:
     const events = helper.eth.normalizeEvents(result.events);
     expect(events).to.be.deep.equal([
       {
@@ -261,6 +218,11 @@
         },
       },
     ]);
+
+    // TODO: why call method reverts?
+    // const actualSponsor = await helpers.methods.sponsor(flipper.options.address).call();
+    // expect(actualSponsor.eth).to.eq(sponsor);
+    // expect(actualSponsor.sub).to.eq('0');
   });
 
   itEth('Sponsor can not be removed by the address that did not deployed the contract', async ({helper}) => {
@@ -276,6 +238,7 @@
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
     
     await expect(helpers.methods.removeSponsor(flipper.options.address).call({from: notOwner})).to.be.rejectedWith('NoPermission');
+    await expect(helpers.methods.removeSponsor(flipper.options.address).send({from: notOwner})).to.be.rejected;
     expect(await helpers.methods.hasSponsor(flipper.options.address).call()).to.be.true;
   });
 
@@ -292,15 +255,15 @@
     await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Generous).send({from: owner});
     await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
 
-    const sponsorBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    const callerBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(caller));
+    const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
+    const callerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(caller));
 
     await flipper.methods.flip().send({from: caller});
     expect(await flipper.methods.getValue().call()).to.be.true;
 
     // Balance should be taken from sponsor instead of caller
-    const sponsorBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    const callerBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(caller));
+    const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
+    const callerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(caller));
     expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
     expect(callerBalanceAfter).to.be.eq(callerBalanceBefore);
   });
@@ -331,82 +294,67 @@
     expect(callerBalanceAfter).to.be.eq(callerBalanceBefore);
   });
 
-  itEth('Sponsoring is set, an address that has no UNQ can send a transaction and it works. Sponsor balance should decrease (allowlisted)', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const caller = helper.eth.createAccount();
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.toggleAllowlist(flipper.options.address, true).send({from: owner});
-    await helpers.methods.toggleAllowed(flipper.options.address, caller, true).send({from: owner});
-
-    await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
-    await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
-
-    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
-    await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
-
-    const sponsorBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    expect(sponsorBalanceBefore).to.be.not.equal('0');
-
-    await flipper.methods.flip().send({from: caller});
-    expect(await flipper.methods.getValue().call()).to.be.true;
-
-    // Balance should be taken from flipper instead of caller
-    const sponsorBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
+  [
+    {balance: 0n, label: '0'},
+    {balance: 10n, label: '10'},
+  ].map(testCase => {
+    itEth(`Allow-listed address that has ${testCase.label} UNQ can call a contract. Sponsor balance should decrease`, async ({helper}) => {
+      const owner = await helper.eth.createAccountWithBalance(donor);
+      const sponsor = await helper.eth.createAccountWithBalance(donor);
+      const caller = helper.eth.createAccount();
+      await helper.eth.transferBalanceFromSubstrate(donor, caller, testCase.balance);
+      const helpers = helper.ethNativeContract.contractHelpers(owner);
+      const flipper = await helper.eth.deployFlipper(owner);
+  
+      await helpers.methods.toggleAllowlist(flipper.options.address, true).send({from: owner});
+      await helpers.methods.toggleAllowed(flipper.options.address, caller, true).send({from: owner});
+  
+      await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
+      await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
+  
+      await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
+      await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
+  
+      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
+      expect(sponsorBalanceBefore > 0n).to.be.true;
+  
+      await flipper.methods.flip().send({from: caller});
+      expect(await flipper.methods.getValue().call()).to.be.true;
+  
+      // Balance should be taken from flipper instead of caller
+      const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
+      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
+      // Caller's balance does not change:
+      const callerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(caller));
+      expect(callerBalanceAfter).to.eq(testCase.balance * nominal);
+    });
   });
 
-  itEth('Sponsoring is set, an address that has no UNQ can send a transaction and it works. Sponsor balance should not decrease (non-allowlisted)', async ({helper}) => {
+  itEth('Non-allow-listed address can call a contract. Sponsor balance should not decrease', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor);
-    const caller = await helper.eth.createAccount();
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
-    await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
+    const caller = helper.eth.createAccount();
+    const contractHelpers = helper.ethNativeContract.contractHelpers(owner);
 
+    // Deploy flipper and send some tokens:
+    const flipper = await helper.eth.deployFlipper(owner);
     await helper.eth.transferBalanceFromSubstrate(donor, flipper.options.address);
-
+    expect(await flipper.methods.getValue().call()).to.be.false;
+    // flipper address has some tokens:
     const originalFlipperBalance = await helper.balance.getEthereum(flipper.options.address);
-    expect(originalFlipperBalance).to.be.not.equal('0');
+    expect(originalFlipperBalance > 0n).to.be.true;
+
+    // Set Allowlisted sponsoring mode. caller is not in allow list:
+    await contractHelpers.methods.toggleAllowlist(flipper.options.address, true).send({from: owner});
+    await contractHelpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
+    await contractHelpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
 
+    // 1. Caller has no UNQ and is not in allow list. So he cannot flip: 
     await expect(flipper.methods.flip().send({from: caller})).to.be.rejectedWith(/Returned error: insufficient funds for gas \* price \+ value/);
     expect(await flipper.methods.getValue().call()).to.be.false;
 
-    // Balance should be taken from flipper instead of caller
-    // FIXME the comment is wrong! What check should be here?
+    // Flipper's balance does not change:
     const balanceAfter = await helper.balance.getEthereum(flipper.options.address);
     expect(balanceAfter).to.be.equal(originalFlipperBalance);
-  });
-
-  itEth('Sponsoring is set, an address that has UNQ can send a transaction and it works. User balance should not change', async ({helper}) => {
-    const owner = await helper.eth.createAccountWithBalance(donor);
-    const sponsor = await helper.eth.createAccountWithBalance(donor);
-    const caller = await helper.eth.createAccountWithBalance(donor);
-    const helpers = helper.ethNativeContract.contractHelpers(owner);
-    const flipper = await helper.eth.deployFlipper(owner);
-
-    await helpers.methods.toggleAllowlist(flipper.options.address, true).send({from: owner});
-    await helpers.methods.toggleAllowed(flipper.options.address, caller, true).send({from: owner});
-
-    await helpers.methods.setSponsoringMode(flipper.options.address, SponsoringMode.Allowlisted).send({from: owner});
-    await helpers.methods.setSponsoringRateLimit(flipper.options.address, 0).send({from: owner});
-
-    await helpers.methods.setSponsor(flipper.options.address, sponsor).send();
-    await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
-
-    const sponsorBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    const callerBalanceBefore = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(caller));
-
-    await flipper.methods.flip().send({from: caller});
-    expect(await flipper.methods.getValue().call()).to.be.true;
-
-    const sponsorBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(sponsor));
-    const callerBalanceAfter = await helper.balance.getSubstrate(await helper.address.ethToSubstrate(caller));
-    expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
-    expect(callerBalanceAfter).to.be.equal(callerBalanceBefore);
   });
 
   itEth('Sponsoring is limited, with setContractRateLimit. The limitation is working if transactions are sent more often, the sender pays the commission.', async ({helper}) => {
@@ -427,7 +375,7 @@
     await helpers.methods.confirmSponsorship(flipper.options.address).send({from: sponsor});
 
     const originalFlipperBalance = await helper.balance.getEthereum(sponsor);
-    expect(originalFlipperBalance).to.be.not.equal('0');
+    expect(originalFlipperBalance > 0n).to.be.true;
 
     await flipper.methods.flip().send({from: caller});
     expect(await flipper.methods.getValue().call()).to.be.true;

--- a/tests/src/eth/events.test.ts
+++ b/tests/src/eth/events.test.ts
@@ -40,7 +40,7 @@
   const {collectionAddress, events: ethEvents} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
   await helper.wait.newBlocks(1);
   {
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionCreated',
         args: {
@@ -49,21 +49,21 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionCreated'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionCreated'}]);
     clearEvents(ethEvents, subEvents);
   }
   {
     const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
     const result = await collectionHelper.methods.destroyCollection(collectionAddress).send({from:owner});
     await helper.wait.newBlocks(1);
-    expect(result.events).to.be.like({
+    expect(result.events).to.containSubset({
       CollectionDestroyed: {
         returnValues: {
           collectionId: collectionAddress,
         },
       },
     });
-    expect(subEvents).to.be.like([{method: 'CollectionDestroyed'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionDestroyed'}]);
   }
   unsubscribe();
 }
@@ -71,7 +71,7 @@
 async function testCollectionPropertySetAndDeleted(helper: EthUniqueHelper, mode: TCollectionMode) {
   const owner = await helper.eth.createAccountWithBalance(donor);
   const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
-  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);
+  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
   const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
     
   const ethEvents: any = [];
@@ -82,7 +82,7 @@
   {
     await collection.methods.setCollectionProperties([{key: 'A', value: [0,1,2,3]}]).send({from:owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -90,13 +90,13 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionPropertySet'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionPropertySet'}]);
     clearEvents(ethEvents, subEvents);
   }
   {
     await collection.methods.deleteCollectionProperties(['A']).send({from:owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -104,7 +104,7 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionPropertyDeleted'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionPropertyDeleted'}]);
   }
   unsubscribe();
 }
@@ -112,7 +112,7 @@
 async function testPropertyPermissionSet(helper: EthUniqueHelper, mode: TCollectionMode) {
   const owner = await helper.eth.createAccountWithBalance(donor);
   const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
-  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);
+  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
   const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
   const ethEvents: any = [];
   collectionHelper.events.allEvents((_: any, event: any) => {
@@ -127,7 +127,7 @@
     ],
   ]).send({from: owner});
   await helper.wait.newBlocks(1);
-  expect(ethEvents).to.be.like([
+  expect(ethEvents).to.containSubset([
     {
       event: 'CollectionChanged',
       returnValues: {
@@ -135,7 +135,7 @@
       },
     },
   ]);
-  expect(subEvents).to.be.like([{method: 'PropertyPermissionSet'}]);
+  expect(subEvents).to.containSubset([{method: 'PropertyPermissionSet'}]);
   unsubscribe();
 }
 
@@ -143,7 +143,7 @@
   const owner = await helper.eth.createAccountWithBalance(donor);
   const user = helper.ethCrossAccount.createAccount();
   const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
-  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);
+  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
   const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
   const ethEvents: any[] = [];
   collectionHelper.events.allEvents((_: any, event: any) => {
@@ -154,7 +154,7 @@
   {
     await collection.methods.addToCollectionAllowListCross(user).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -162,14 +162,13 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'AllowListAddressAdded'}]);
+    expect(subEvents).to.containSubset([{method: 'AllowListAddressAdded'}]);
     clearEvents(ethEvents, subEvents);
   }
   {
     await collection.methods.removeFromCollectionAllowListCross(user).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents.length).to.be.eq(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -177,7 +176,7 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'AllowListAddressRemoved'}]);
+    expect(subEvents).to.containSubset([{method: 'AllowListAddressRemoved'}]);
   }
   unsubscribe();
 }
@@ -186,7 +185,7 @@
   const owner = await helper.eth.createAccountWithBalance(donor);
   const user = helper.ethCrossAccount.createAccount();
   const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
-  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);
+  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
   const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
   const ethEvents: any = [];
   collectionHelper.events.allEvents((_: any, event: any) => {
@@ -196,7 +195,7 @@
   {
     await collection.methods.addCollectionAdminCross(user).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -204,13 +203,13 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionAdminAdded'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionAdminAdded'}]);
     clearEvents(ethEvents, subEvents);
   }
   {
     await collection.methods.removeCollectionAdminCross(user).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -218,7 +217,7 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionAdminRemoved'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionAdminRemoved'}]);
   }
   unsubscribe();
 }
@@ -226,7 +225,7 @@
 async function testCollectionLimitSet(helper: EthUniqueHelper, mode: TCollectionMode) {
   const owner = await helper.eth.createAccountWithBalance(donor);
   const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
-  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);
+  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
   const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
   const ethEvents: any = [];
   collectionHelper.events.allEvents((_: any, event: any) => {
@@ -236,7 +235,7 @@
   {
     await collection.methods.setCollectionLimit(CollectionLimits.OwnerCanTransfer, true, 0).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -244,7 +243,7 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionLimitSet'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionLimitSet'}]);
   }
   unsubscribe();
 }
@@ -253,7 +252,7 @@
   const owner = await helper.eth.createAccountWithBalance(donor);
   const newOwner = helper.ethCrossAccount.createAccount();
   const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
-  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);
+  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
   const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
   const ethEvents: any = [];
   collectionHelper.events.allEvents((_: any, event: any) => {
@@ -263,7 +262,7 @@
   {
     await collection.methods.changeCollectionOwnerCross(newOwner).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -271,7 +270,7 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionOwnerChanged'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionOwnerChanged'}]);
   }
   unsubscribe();
 }
@@ -279,7 +278,7 @@
 async function testCollectionPermissionSet(helper: EthUniqueHelper, mode: TCollectionMode) {
   const owner = await helper.eth.createAccountWithBalance(donor);
   const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
-  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);
+  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
   const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
   const ethEvents: any = [];
   collectionHelper.events.allEvents((_: any, event: any) => {
@@ -289,7 +288,7 @@
   {
     await collection.methods.setCollectionMintMode(true).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -297,13 +296,13 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionPermissionSet'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionPermissionSet'}]);
     clearEvents(ethEvents, subEvents);
   }
   {
     await collection.methods.setCollectionAccess(1).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -311,7 +310,7 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionPermissionSet'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionPermissionSet'}]);
   }
   unsubscribe();
 }
@@ -320,7 +319,7 @@
   const owner = await helper.eth.createAccountWithBalance(donor);
   const sponsor = await helper.ethCrossAccount.createAccountWithBalance(donor);
   const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
-  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);
+  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
   const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
   const ethEvents: any = [];
   collectionHelper.events.allEvents((_: any, event: any) => {
@@ -332,21 +331,19 @@
   {
     await collection.methods.setCollectionSponsorCross(sponsor).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
-      {
-        event: 'CollectionChanged',
-        returnValues: {
-          collectionId: collectionAddress,
-        },
+    expect(ethEvents).to.containSubset([{
+      event: 'CollectionChanged',
+      returnValues: {
+        collectionId: collectionAddress,
       },
-    ]);
-    expect(subEvents).to.be.like([{method: 'CollectionSponsorSet'}]);
+    }]);
+    expect(subEvents).to.containSubset([{method: 'CollectionSponsorSet'}]);
     clearEvents(ethEvents, subEvents);
   }
   {
     await collection.methods.confirmCollectionSponsorship().send({from: sponsor.eth});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -354,13 +351,13 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'SponsorshipConfirmed'}]);
+    expect(subEvents).to.containSubset([{method: 'SponsorshipConfirmed'}]);
     clearEvents(ethEvents, subEvents);
   }
   {
     await collection.methods.removeCollectionSponsor().send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'CollectionChanged',
         returnValues: {
@@ -368,7 +365,7 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'CollectionSponsorRemoved'}]);
+    expect(subEvents).to.containSubset([{method: 'CollectionSponsorRemoved'}]);
   }
   unsubscribe();
 }
@@ -376,7 +373,7 @@
 async function testTokenPropertySetAndDeleted(helper: EthUniqueHelper, mode: TCollectionMode) {
   const owner = await helper.eth.createAccountWithBalance(donor);
   const {collectionAddress} = await helper.eth.createCollection(mode, owner, 'A', 'B', 'C');
-  const collection = await helper.ethNativeContract.collection(collectionAddress, mode, owner);
+  const collection = helper.ethNativeContract.collection(collectionAddress, mode, owner);
   const collectionHelper = helper.ethNativeContract.collectionHelpers(owner);
   const result = await collection.methods.mint(owner).send({from: owner});
   const tokenId = result.events.Transfer.returnValues.tokenId;
@@ -397,7 +394,7 @@
   {
     await collection.methods.setProperties(tokenId, [{key: 'A', value: [1,2,3]}]).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'TokenChanged',
         returnValues: {
@@ -405,13 +402,13 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'TokenPropertySet'}]);
+    expect(subEvents).to.containSubset([{method: 'TokenPropertySet'}]);
     clearEvents(ethEvents, subEvents);
   }
   {
     await collection.methods.deleteProperties(tokenId, ['A']).send({from: owner});
     await helper.wait.newBlocks(1);
-    expect(ethEvents).to.be.like([
+    expect(ethEvents).to.containSubset([
       {
         event: 'TokenChanged',
         returnValues: {
@@ -419,7 +416,7 @@
         },
       },
     ]);
-    expect(subEvents).to.be.like([{method: 'TokenPropertyDeleted'}]);
+    expect(subEvents).to.containSubset([{method: 'TokenPropertyDeleted'}]);
   }
   unsubscribe();
 }

--- 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}) => {
@@ -169,6 +186,68 @@
     }
   });
 
+  itEth('Can perform approveCross()', async ({helper}) => {
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const spender = helper.eth.createAccount();
+    const spenderSub = (await helper.arrange.createAccounts([1n], donor))[0];
+    const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);
+    const spenderCrossSub = helper.ethCrossAccount.fromKeyringPair(spenderSub);
+    
+
+    const collection = await helper.ft.mintCollection(alice);
+    await collection.mint(alice, 200n, {Ethereum: owner});
+
+    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
+
+    {
+      const result = await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});
+      const event = result.events.Approval;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.owner).to.be.equal(owner);
+      expect(event.returnValues.spender).to.be.equal(spender);
+      expect(event.returnValues.value).to.be.equal('100');
+    }
+
+    {
+      const allowance = await contract.methods.allowance(owner, spender).call();
+      expect(+allowance).to.equal(100);
+    }
+    
+    
+    {
+      const result = await contract.methods.approveCross(spenderCrossSub, 100).send({from: owner});
+      const event = result.events.Approval;
+      expect(event.address).to.be.equal(collectionAddress);
+      expect(event.returnValues.owner).to.be.equal(owner);
+      expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(spenderSub.address));
+      expect(event.returnValues.value).to.be.equal('100');
+    }
+
+    {
+      const allowance = await collection.getApprovedTokens({Ethereum: owner}, {Substrate: spenderSub.address});
+      expect(allowance).to.equal(100n);
+    }
+  
+    {
+      //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call()
+    }
+  });
+
+  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {
+    const nonOwner = await helper.eth.createAccountWithBalance(donor);
+    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const collection = await helper.ft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    await collection.mint(alice, 100n, {Ethereum: owner});
+
+    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
+
+    await expect(collectionEvm.methods.approveCross(nonOwnerCross, 20).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');
+  });
+
+
   itEth('Can perform burnFromCross()', async ({helper}) => {
     const sender = await helper.eth.createAccountWithBalance(donor, 100n);
 

--- a/tests/src/eth/nonFungible.test.ts
+++ b/tests/src/eth/nonFungible.test.ts
@@ -175,55 +175,82 @@
     // expect(tokenUri).to.be.equal(`https://offchain-service.local/token-info/${nextTokenId}`);
   });
   
-  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,
-          },
-        };
-      });
+  // TODO combine all minting tests in one place
+  [
+    '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 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: false,
+              collectionAdmin: true,
+              mutable: false,
+            },
+          };
+        });
     
     
-    const collection = await helper.nft.mintCollection(minter, {
-      tokenPrefix: 'ethp',
-      tokenPropertyPermissions: permissions,
-    });
-    await collection.addAdmin(minter, {Ethereum: caller});
+      const collection = await helper.nft.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, 'nft', 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, 'nft', 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('Non-owner and non admin cannot mintCross', async ({helper}) => {
+    const nonOwner = await helper.eth.createAccountWithBalance(donor);
+    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
+
+    const collection = await helper.nft.mintCollection(minter);
+    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
+    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'nft');
+
+    await expect(collectionEvm.methods.mintCross(nonOwnerCross, []).call({from: nonOwner}))
+      .to.be.rejectedWith('PublicMintingNotAllowed');
   });
   
   //TODO: CORE-302 add eth methods
@@ -375,6 +402,8 @@
         },
       });
     }
+
+    expect(await helper.nft.doesTokenExist(collection.collectionId, token.tokenId)).to.be.false;
   });
   
   itEth('Can perform transfer with ApprovalForAll', async ({helper}) => {
@@ -455,6 +484,7 @@
     expect(await token2.doesExist()).to.be.false;
   });
 
+  // TODO combine all approve tests in one place
   itEth('Can perform approveCross()', async ({helper}) => {
     // arrange: create accounts
     const owner = await helper.eth.createAccountWithBalance(donor, 100n);
@@ -503,6 +533,17 @@
     expect(await helper.nft.getTokenOwner(collection.collectionId, token2.tokenId)).to.deep.eq({Ethereum: receiverEth.toLowerCase()});
   });
 
+  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {
+    const nonOwner = await helper.eth.createAccountWithBalance(donor);
+    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const collection = await helper.nft.mintCollection(minter, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const collectionEvm = helper.ethNativeContract.collection(helper.ethAddress.fromCollectionId(collection.collectionId), 'nft');
+    const token = await collection.mintToken(minter, {Ethereum: owner});
+
+    await expect(collectionEvm.methods.approveCross(nonOwnerCross, token.tokenId).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');
+  });
+
   itEth('Can reaffirm approved address', async ({helper}) => {
     const owner = await helper.eth.createAccountWithBalance(donor, 100n);
     const ownerCrossEth = helper.ethCrossAccount.fromAddress(owner);

--- a/tests/src/eth/reFungible.test.ts
+++ b/tests/src/eth/reFungible.test.ts
@@ -137,48 +137,63 @@
     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: false,
+        collectionAdmin: true,
+        mutable: false}};
+      });
     
     
-    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}) => {

--- a/tests/src/eth/reFungibleToken.test.ts
+++ b/tests/src/eth/reFungibleToken.test.ts
@@ -207,7 +207,20 @@
       //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call()
     }
   });
-  
+
+  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {
+    const nonOwner = await helper.eth.createAccountWithBalance(donor);
+    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
+    const owner = await helper.eth.createAccountWithBalance(donor);
+    const collection = await helper.rft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
+    const token = await collection.mintToken(alice, 100n, {Ethereum: owner});
+
+    const tokenAddress = helper.ethAddress.fromTokenId(collection.collectionId, token.tokenId);
+    const tokenEvm = helper.ethNativeContract.rftToken(tokenAddress, owner);
+
+    await expect(tokenEvm.methods.approveCross(nonOwnerCross, 20).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');
+  });
+
   [
     'transferFrom',
     'transferFromCross',