test: added test for primary market fee

packages/marketplace/contracts/transfer-manager/TransferManager.sol

@@ -106,10 +106,10 @@ abstract contract TransferManager is ERC165Upgradeable, ITransferManager {
         LibFeeSide.FeeSide feeSide
     ) internal override {
         if (feeSide == LibFeeSide.FeeSide.LEFT) {
-            doTransfersWithRoyalties(left, right);
+            doTransfersWithFees(left, right);
             transferPayouts(right.asset.assetType, right.asset.value, right.from, left.payouts);
         } else if (feeSide == LibFeeSide.FeeSide.RIGHT) {
-            doTransfersWithRoyalties(right, left);
+            doTransfersWithFees(right, left);
             transferPayouts(left.asset.assetType, left.asset.value, left.from, right.payouts);
         } else {
             transferPayouts(left.asset.assetType, left.asset.value, left.from, right.payouts);
@@ -120,7 +120,7 @@ abstract contract TransferManager is ERC165Upgradeable, ITransferManager {
     /// @notice executes the fee-side transfers (payment + fees)
     /// @param paymentSide DealSide of the fee-side order
     /// @param nftSide DealSide of the nft-side order
-    function doTransfersWithRoyalties(LibDeal.DealSide memory paymentSide, LibDeal.DealSide memory nftSide) internal {
+    function doTransfersWithFees(LibDeal.DealSide memory paymentSide, LibDeal.DealSide memory nftSide) internal {
         uint256 rest = paymentSide.asset.value;
 
         rest = transferRoyalties(

packages/marketplace/test/exchange/Exchange.test.ts

@@ -414,6 +414,96 @@ describe('Exchange.sol', function () {
     );
   });
 
+  it('should execute a complete match order between ERC721 and ERC20 tokens in primary market', async function () {
+    const {
+      ExchangeContractAsUser,
+      OrderValidatorAsDeployer,
+      ERC20Contract,
+      ERC721WithRoyaltyV2981,
+      defaultFeeReceiver,
+      deployer: maker, // making deployer the maker to sell in primary market
+      user2: taker,
+    } = await loadFixture(deployFixtures);
+
+    await ERC721WithRoyaltyV2981.mint(maker.address, 1, [
+      await FeeRecipientsData(maker.address, 10000),
+    ]);
+
+    await ERC721WithRoyaltyV2981.connect(maker).approve(
+      await ExchangeContractAsUser.getAddress(),
+      1
+    );
+    await ERC20Contract.mint(taker.address, 100000000000);
+    await ERC20Contract.connect(taker).approve(
+      await ExchangeContractAsUser.getAddress(),
+      100000000000
+    );
+
+    expect(await ERC721WithRoyaltyV2981.ownerOf(1)).to.be.equal(maker.address);
+    expect(await ERC20Contract.balanceOf(taker.address)).to.be.equal(
+      100000000000
+    );
+    const makerAsset = await AssetERC721(ERC721WithRoyaltyV2981, 1);
+    const takerAsset = await AssetERC20(ERC20Contract, 100000000000);
+    const leftOrder = await OrderDefault(
+      maker,
+      makerAsset,
+      ZeroAddress,
+      takerAsset,
+      1,
+      0,
+      0
+    );
+    const rightOrder = await OrderDefault(
+      taker,
+      takerAsset,
+      ZeroAddress,
+      makerAsset,
+      1,
+      0,
+      0
+    );
+    const makerSig = await signOrder(
+      leftOrder,
+      maker,
+      OrderValidatorAsDeployer
+    );
+    const takerSig = await signOrder(
+      rightOrder,
+      taker,
+      OrderValidatorAsDeployer
+    );
+
+    expect(await ExchangeContractAsUser.fills(hashKey(leftOrder))).to.be.equal(
+      0
+    );
+    expect(await ExchangeContractAsUser.fills(hashKey(rightOrder))).to.be.equal(
+      0
+    );
+
+    await ExchangeContractAsUser.matchOrders(
+      leftOrder,
+      makerSig,
+      rightOrder,
+      takerSig
+    );
+    expect(await ExchangeContractAsUser.fills(hashKey(leftOrder))).to.be.equal(
+      100000000000
+    );
+    expect(await ExchangeContractAsUser.fills(hashKey(rightOrder))).to.be.equal(
+      1
+    );
+    expect(await ERC721WithRoyaltyV2981.ownerOf(1)).to.be.equal(taker.address);
+    expect(await ERC20Contract.balanceOf(maker.address)).to.be.equal(
+      98770000000
+    );
+
+    // check primary market protocol fee
+    expect(
+      await ERC20Contract.balanceOf(defaultFeeReceiver.address)
+    ).to.be.equal(1230000000); // 123 * 100000000000 / 10000 = 1230000000
+  });
+
   it('should execute a complete match order between ERC721 and ERC20 tokens', async function () {
     const {
       ExchangeContractAsUser,

packages/marketplace/test/fixtures.ts

@@ -69,7 +69,7 @@ async function deploy() {
   );
 
   const TestERC721WithRoyaltyV2981Factory = await ethers.getContractFactory(
-    'TestERC721WithRoyaltyV2981'
+    'TestERC721WithRoyaltyV2981Multi'
   );
   const ERC721WithRoyaltyV2981 = await upgrades.deployProxy(
     TestERC721WithRoyaltyV2981Factory,
@@ -78,6 +78,7 @@ async function deploy() {
       initializer: 'initialize',
     }
   );
+  await ERC721WithRoyaltyV2981.waitForDeployment();
 
   const ERC20ContractFactory = await ethers.getContractFactory('TestERC20');
   const ERC20Contract = await ERC20ContractFactory.deploy();

packages/marketplace/test/utils/assets.ts

@@ -7,6 +7,7 @@ import {
   Numeric,
   BytesLike,
   Contract,
+  AddressLike,
   keccak256,
   solidityPackedKeccak256,
 } from 'ethers';
@@ -30,6 +31,11 @@ export const ASSET_TYPEHASH = keccak256(
   )
 );
 
+export type FeeRecipients = {
+  recipient: AddressLike;
+  bps: Numeric;
+};
+
 export type AssetType = {
   assetClass: HashSignature;
   data: BytesLike;
@@ -48,6 +54,14 @@ export const AssetETH = (value: Numeric): Asset => ({
   value,
 });
 
+export const FeeRecipientsData = async (
+  recipient: AddressLike,
+  bps: Numeric
+): Promise<FeeRecipients> => ({
+  recipient,
+  bps,
+});
+
 export const AssetERC20 = async (
   tokenContract: Contract,
   value: Numeric