git.delta.rocks / unique-network / refs/commits / 534b1e6a235d

186    }186    }
187  });187  });
188
189  itEth('Can perform approveCross()', async ({helper}) => {
190    const owner = await helper.eth.createAccountWithBalance(donor);
191    const spender = helper.eth.createAccount();
192    const spenderSub = (await helper.arrange.createAccounts([1n], donor))[0];
193    const spenderCrossEth = helper.ethCrossAccount.fromAddress(spender);
194    const spenderCrossSub = helper.ethCrossAccount.fromKeyringPair(spenderSub);
195    
196
197    const collection = await helper.ft.mintCollection(alice);
198    await collection.mint(alice, 200n, {Ethereum: owner});
199
200    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
201    const contract = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
202
203    {
204      const result = await contract.methods.approveCross(spenderCrossEth, 100).send({from: owner});
205      const event = result.events.Approval;
206      expect(event.address).to.be.equal(collectionAddress);
207      expect(event.returnValues.owner).to.be.equal(owner);
208      expect(event.returnValues.spender).to.be.equal(spender);
209      expect(event.returnValues.value).to.be.equal('100');
210    }
211
212    {
213      const allowance = await contract.methods.allowance(owner, spender).call();
214      expect(+allowance).to.equal(100);
215    }
216    
217    
218    {
219      const result = await contract.methods.approveCross(spenderCrossSub, 100).send({from: owner});
220      const event = result.events.Approval;
221      expect(event.address).to.be.equal(collectionAddress);
222      expect(event.returnValues.owner).to.be.equal(owner);
223      expect(event.returnValues.spender).to.be.equal(helper.address.substrateToEth(spenderSub.address));
224      expect(event.returnValues.value).to.be.equal('100');
225    }
226
227    {
228      const allowance = await collection.getApprovedTokens({Ethereum: owner}, {Substrate: spenderSub.address});
229      expect(allowance).to.equal(100n);
230    }
231  
232    {
233      //TO-DO expect with future allowanceCross(owner, spenderCrossEth).call()
234    }
235  });
236
237  itEth('Non-owner and non admin cannot approveCross', async ({helper}) => {
238    const nonOwner = await helper.eth.createAccountWithBalance(donor);
239    const nonOwnerCross = helper.ethCrossAccount.fromAddress(nonOwner);
240    const owner = await helper.eth.createAccountWithBalance(donor);
241    const collection = await helper.ft.mintCollection(alice, {name: 'A', description: 'B', tokenPrefix: 'C'});
242    await collection.mint(alice, 100n, {Ethereum: owner});
243
244    const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
245    const collectionEvm = helper.ethNativeContract.collection(collectionAddress, 'ft', owner);
246
247    await expect(collectionEvm.methods.approveCross(nonOwnerCross, 20).call({from: nonOwner})).to.be.rejectedWith('CantApproveMoreThanOwned');
248  });
249
188250
189  itEth('Can perform burnFromCross()', async ({helper}) => {251  itEth('Can perform burnFromCross()', async ({helper}) => {

--- a/tests/src/eth/nonFungible.test.ts
+++ b/tests/src/eth/nonFungible.test.ts
@@ -194,9 +194,9 @@
         .map(p => {
           return {
             key: p.key, permission: {
-              tokenOwner: true,
+              tokenOwner: false,
               collectionAdmin: true,
-              mutable: true,
+              mutable: false,
             },
           };
         });
@@ -482,6 +482,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);
@@ -530,6 +531,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
@@ -150,9 +150,11 @@
       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,
+      const permissions: ITokenPropertyPermission[] = properties.map(p => { return {key: p.key, permission: {
+        tokenOwner: false,
         collectionAdmin: true,
-        mutable: true}}; });
+        mutable: false}};
+      });
     
     
       const collection = await helper.rft.mintCollection(minter, {

--- 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',