Merge pull request #1085 from thesandboxgame/task/add-trusted-forward…

…er-operator-filter

Added trusted forwarder test cases for operator filter and royalties

packages/asset/test/Asset.test.ts

@@ -12,6 +12,7 @@ import {
   RoyaltyMultiRecipientsInterfaceId,
   RoyaltyUGCInterfaceId,
 } from './utils/interfaceIds';
+import {BigNumber} from 'ethers';
 const zeroAddress = '0x0000000000000000000000000000000000000000';
 
 describe('Base Asset Contract (/packages/asset/contracts/Asset.sol)', function () {
@@ -1002,15 +1003,15 @@ describe('Base Asset Contract (/packages/asset/contracts/Asset.sol)', function (
         const {
           operatorFilterRegistry,
           assetAdmin,
-          trustedForwarder,
+          TrustedForwarder,
           filterOperatorSubscription,
           RoyaltyManagerContract,
         } = await setupOperatorFilter();
         const AssetFactory = await ethers.getContractFactory('Asset');
         const Asset = await upgrades.deployProxy(
           AssetFactory,
           [
-            trustedForwarder.address,
+            TrustedForwarder.address,
             assetAdmin.address,
             'ipfs://',
             filterOperatorSubscription.address,
@@ -1045,15 +1046,15 @@ describe('Base Asset Contract (/packages/asset/contracts/Asset.sol)', function (
       it('should revert when registry is set zero and subscription is set zero', async function () {
         const {
           assetAdmin,
-          trustedForwarder,
+          TrustedForwarder,
           filterOperatorSubscription,
           RoyaltyManagerContract,
         } = await setupOperatorFilter();
         const AssetFactory = await ethers.getContractFactory('Asset');
         const Asset = await upgrades.deployProxy(
           AssetFactory,
           [
-            trustedForwarder.address,
+            TrustedForwarder.address,
             assetAdmin.address,
             'ipfs://',
             filterOperatorSubscription.address,
@@ -1076,7 +1077,7 @@ describe('Base Asset Contract (/packages/asset/contracts/Asset.sol)', function (
       it('should revert when registry is set and subscription is set by non-admin', async function () {
         const {
           assetAdmin,
-          trustedForwarder,
+          TrustedForwarder,
           filterOperatorSubscription,
           RoyaltyManagerContract,
           operatorFilterRegistry,
@@ -1087,7 +1088,49 @@ describe('Base Asset Contract (/packages/asset/contracts/Asset.sol)', function (
         const Asset = await upgrades.deployProxy(
           AssetFactory,
           [
-            trustedForwarder.address,
+            TrustedForwarder.address,
+            assetAdmin.address,
+            'ipfs://',
+            filterOperatorSubscription.address,
+            RoyaltyManagerContract.address,
+          ],
+          {
+            initializer: 'initialize',
+          }
+        );
+
+        await expect(
+          Asset.connect(user1).setOperatorRegistry(
+            operatorFilterRegistry.address
+          )
+        ).to.be.revertedWith(
+          `AccessControl: account ${user1.address.toLocaleLowerCase()} is missing role ${defaultAdminRole}`
+        );
+
+        await expect(
+          Asset.connect(user1).registerAndSubscribe(
+            filterOperatorSubscription.address,
+            true
+          )
+        ).to.be.revertedWith(
+          `AccessControl: account ${user1.address.toLocaleLowerCase()} is missing role ${defaultAdminRole}`
+        );
+      });
+      it('should not revert when registry is set and subscription is set by admin through trusted forwarder', async function () {
+        const {
+          assetAdmin,
+          TrustedForwarder,
+          filterOperatorSubscription,
+          RoyaltyManagerContract,
+          operatorFilterRegistry,
+          defaultAdminRole,
+          user1,
+        } = await setupOperatorFilter();
+        const AssetFactory = await ethers.getContractFactory('Asset');
+        const Asset = await upgrades.deployProxy(
+          AssetFactory,
+          [
+            TrustedForwarder.address,
             assetAdmin.address,
             'ipfs://',
             filterOperatorSubscription.address,
@@ -1651,6 +1694,30 @@ describe('Base Asset Contract (/packages/asset/contracts/Asset.sol)', function (
         ).to.be.revertedWith;
       });
 
+      it('it should not be able to setApprovalForAll trusted forwarder if black listed', async function () {
+        const {
+          operatorFilterRegistryAsSubscription,
+          filterOperatorSubscription,
+          users,
+          TrustedForwarder,
+        } = await setupOperatorFilter();
+
+        const TrustedForwarderCodeHash =
+          await operatorFilterRegistryAsSubscription.codeHashOf(
+            TrustedForwarder.address
+          );
+
+        await operatorFilterRegistryAsSubscription.updateCodeHash(
+          filterOperatorSubscription.address,
+          TrustedForwarderCodeHash,
+          true
+        );
+
+        await expect(
+          users[1].Asset.setApprovalForAll(TrustedForwarder.address, true)
+        ).to.be.revertedWithCustomError;
+      });
+
       it('it should be able to setApprovalForAll blacklisted market places after they are removed from the blacklist ', async function () {
         const {
           mockMarketPlace1,
@@ -1755,6 +1822,54 @@ describe('Base Asset Contract (/packages/asset/contracts/Asset.sol)', function (
         ).to.be.revertedWithCustomError;
       });
 
+      it('it should be able to transfer through trusted forwarder after it is blacklisted', async function () {
+        const {
+          Asset,
+          users,
+          operatorFilterRegistryAsSubscription,
+          filterOperatorSubscription,
+          TrustedForwarder,
+        } = await setupOperatorFilter();
+        await Asset.mintWithoutMinterRole(users[0].address, 1, 2);
+
+        await operatorFilterRegistryAsSubscription.updateOperator(
+          filterOperatorSubscription.address,
+          TrustedForwarder.address,
+          true
+        );
+
+        const data = await Asset.connect(
+          users[0].Asset.signer
+        ).populateTransaction[
+          'safeTransferFrom(address,address,uint256,uint256,bytes)'
+        ](users[0].address, users[1].address, 1, 1, '0x');
+
+        await TrustedForwarder.execute({...data, value: BigNumber.from(0)});
+
+        expect(await Asset.balanceOf(users[1].address, 1)).to.be.equal(1);
+      });
+
+      it('it should not be able to transfer through trusted forwarder after if sender is blacklisted', async function () {
+        const {Asset, users, TrustedForwarder, mockMarketPlace1} =
+          await setupOperatorFilter();
+        await Asset.mintWithoutMinterRole(users[0].address, 1, 2);
+
+        await users[0].Asset.setApprovalForAllWithoutFilter(
+          mockMarketPlace1.address,
+          true
+        );
+
+        const data = await Asset.connect(
+          ethers.provider.getSigner(mockMarketPlace1.address)
+        ).populateTransaction[
+          'safeTransferFrom(address,address,uint256,uint256,bytes)'
+        ](users[0].address, users[1].address, 1, 1, '0x');
+
+        await expect(
+          TrustedForwarder.execute({...data, value: BigNumber.from(0)})
+        ).to.be.revertedWith('Call execution failed');
+      });
+
       it('it should be able to transfer through non blacklisted market places', async function () {
         const {mockMarketPlace3, Asset, users} = await setupOperatorFilter();
         await Asset.mintWithoutMinterRole(users[0].address, 1, 1);
@@ -2068,6 +2183,64 @@ describe('Base Asset Contract (/packages/asset/contracts/Asset.sol)', function (
         expect(await Asset.balanceOf(users[1].address, 1)).to.be.equal(1);
         expect(await Asset.balanceOf(users[1].address, 2)).to.be.equal(1);
       });
+      it('should be able to batch transfer through trusted forwarder if it is black listed', async function () {
+        const {
+          Asset,
+          users,
+          operatorFilterRegistryAsSubscription,
+          filterOperatorSubscription,
+          TrustedForwarder,
+        } = await setupOperatorFilter();
+        const TrustedForwarderCodeHash =
+          await operatorFilterRegistryAsSubscription.codeHashOf(
+            TrustedForwarder.address
+          );
+        await Asset.mintWithoutMinterRole(users[0].address, 1, 1);
+        await Asset.mintWithoutMinterRole(users[0].address, 2, 1);
+
+        await operatorFilterRegistryAsSubscription.updateCodeHash(
+          filterOperatorSubscription.address,
+          TrustedForwarderCodeHash,
+          true
+        );
+
+        await operatorFilterRegistryAsSubscription.updateOperator(
+          filterOperatorSubscription.address,
+          TrustedForwarder.address,
+          true
+        );
+        const data = await Asset.connect(
+          users[0].Asset.signer
+        ).populateTransaction[
+          'safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)'
+        ](users[0].address, users[1].address, [1, 2], [1, 1], '0x');
+
+        await TrustedForwarder.execute({...data, value: BigNumber.from(0)});
+        expect(await Asset.balanceOf(users[1].address, 1)).to.be.equal(1);
+        expect(await Asset.balanceOf(users[1].address, 2)).to.be.equal(1);
+      });
+      it('should not be able to batch transfer through trusted forwarder if the sender is black listed', async function () {
+        const {Asset, users, TrustedForwarder, mockMarketPlace1} =
+          await setupOperatorFilter();
+
+        await Asset.mintWithoutMinterRole(users[0].address, 1, 1);
+        await Asset.mintWithoutMinterRole(users[0].address, 2, 1);
+
+        await users[0].Asset.setApprovalForAllWithoutFilter(
+          mockMarketPlace1.address,
+          true
+        );
+
+        const data = await Asset.connect(
+          ethers.provider.getSigner(mockMarketPlace1.address)
+        ).populateTransaction[
+          'safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)'
+        ](users[0].address, users[1].address, [1, 2], [1, 1], '0x');
+
+        await expect(
+          TrustedForwarder.execute({...data, value: BigNumber.from(0)})
+        ).to.be.revertedWith('Call execution failed');
+      });
     });
   });
 });

packages/asset/test/AssetRoyalty.test.ts

@@ -139,6 +139,84 @@ describe('Asset Royalties', function () {
       );
     });
 
+    it('should revert split ERC20 using EIP2981 using non trusted forwarder', async function () {
+      const {
+        Asset,
+        ERC20,
+        mockMarketplace,
+        ERC20AsBuyer,
+        seller,
+        buyer,
+        commonRoyaltyReceiver,
+        creator,
+        AssetAsSeller,
+        RoyaltyManagerContract,
+        assetAsMinter,
+        NonTrustedForwarder,
+      } = await assetRoyaltyDistribution();
+
+      const id = generateAssetId(creator.address, 1);
+      await assetAsMinter.mint(seller.address, id, 1, '0x');
+      await ERC20.mint(buyer.address, 1000000);
+      await ERC20AsBuyer.approve(mockMarketplace.address, 1000000);
+      await AssetAsSeller.setApprovalForAll(mockMarketplace.address, true);
+      expect(await Asset.balanceOf(seller.address, id)).to.be.equals(1);
+      await mockMarketplace.distributeRoyaltyEIP2981(
+        1000000,
+        ERC20.address,
+        Asset.address,
+        id,
+        buyer.address,
+        seller.address,
+        true
+      );
+      const splitter = await RoyaltyManagerContract._creatorRoyaltiesSplitter(
+        creator.address
+      );
+
+      const assetRoyaltyBPS = await RoyaltyManagerContract.getContractRoyalty(
+        Asset.address
+      );
+
+      const splitterContract = await ethers.getContractAt(
+        splitterAbi,
+        splitter
+      );
+
+      const balance = await ERC20.balanceOf(splitter);
+
+      expect(balance).to.be.equal(1000000 * (assetRoyaltyBPS / 10000));
+
+      const data = await splitterContract
+        .connect(creator.address)
+        .populateTransaction['splitERC20Tokens(address)'](ERC20.address);
+
+      await expect(
+        NonTrustedForwarder.execute({...data, value: BigNumber.from(0)})
+      ).to.be.revertedWith('Call execution failed');
+
+      const balanceCreator = await ERC20.balanceOf(creator.address);
+      const balanceCommonRoyaltyReceiver = await ERC20.balanceOf(
+        commonRoyaltyReceiver.address
+      );
+
+      const newbalance = await ERC20.balanceOf(splitter);
+
+      expect(newbalance).to.be.equal(1000000 * (assetRoyaltyBPS / 10000));
+
+      expect(balanceCreator).to.be.equal(0);
+      expect(balanceCommonRoyaltyReceiver).to.be.equal(0);
+    });
+
+    it('should get trusted forwarder from Royalty Manager', async function () {
+      const {RoyaltyManagerContract, TrustedForwarder} =
+        await assetRoyaltyDistribution();
+
+      expect(await RoyaltyManagerContract.getTrustedForwarder()).to.be.equal(
+        TrustedForwarder.address
+      );
+    });
+
     it('should split ERC20 using RoyaltyEngine', async function () {
       const {
         Asset,