fix: lint

Author: dawar2151

contracts/TokenCreator.sol

@@ -1,6 +1,3 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
 import "./tokens/ERC20.sol";
 import "./tokens/ERC721.sol";
 import "./tokens/ERC1155.sol";
@@ -19,24 +16,31 @@ contract TokenCreator is Ownable {
         creationFee = _creationFee;
     }
 
-    function createERC20(string memory name, string memory symbol, uint8 decimals, uint256 initialSupply) external payable {
-        require(msg.value == creationFee, InsufficientFee());
-        ERC20Token newToken = new ERC20Token(name, symbol, decimals, initialSupply, msg.sender);
+    modifier requiresFee() {
+        if (msg.value != creationFee) {
+            revert InsufficientFee();
+        }
         payable(owner()).transfer(msg.value);
+        _;
+    }
+
+    function createERC20(
+        string memory name,
+        string memory symbol,
+        uint8 decimals,
+        uint256 initialSupply
+    ) external payable requiresFee {
+        ERC20Token newToken = new ERC20Token(name, symbol, decimals, initialSupply, msg.sender);
         emit ERC20Created(address(newToken));
     }
 
-    function createERC721(string memory name, string memory symbol) external payable {
-        require(msg.value == creationFee, InsufficientFee());
+    function createERC721(string memory name, string memory symbol) external payable requiresFee {
         ERC721Token newToken = new ERC721Token(name, symbol, msg.sender);
-        payable(owner()).transfer(msg.value);
         emit ERC721Created(address(newToken));
     }
 
-    function createERC1155(string memory uri) external payable {
-        require(msg.value == creationFee, InsufficientFee());
+    function createERC1155(string memory uri) external payable requiresFee {
         ERC1155Token newToken = new ERC1155Token(uri, msg.sender);
-        payable(owner()).transfer(msg.value);
         emit ERC1155Created(address(newToken));
     }
-}
+}

test/TokenCreator.ts

@@ -15,16 +15,21 @@ describe("TokenCreator", () => {
     ownerAddress = owner.address;
     creatorAddress = account1.address;
 
-    tokenCreator = await hre.ethers.deployContract("TokenCreator", [fee, ownerAddress]);
+    tokenCreator = await hre.ethers.deployContract("TokenCreator", [
+      fee,
+      ownerAddress,
+    ]);
   });
 
   const extractTokenAddressFromEvent = async (
     tx: any,
-    eventName: string
+    eventName: string,
   ): Promise<string> => {
     const receipt = await tx.wait();
     const eventSignature = hre.ethers.id(`${eventName}(address)`);
-    const log = receipt.logs.find((log: any) => log.topics[0] === eventSignature);
+    const log = receipt.logs.find(
+      (log: any) => log.topics[0] === eventSignature,
+    );
 
     expect(log, `${eventName} event not found`).to.not.be.undefined;
 
@@ -34,19 +39,19 @@ describe("TokenCreator", () => {
   describe("Creation Events", () => {
     it("should emit ERC20Created", async () => {
       await expect(
-        tokenCreator.createERC20("TOS", "TSA", 12, 1000, { value: fee })
+        tokenCreator.createERC20("TOS", "TSA", 12, 1000, { value: fee }),
       ).to.emit(tokenCreator, "ERC20Created");
     });
 
     it("should emit ERC721Created", async () => {
       await expect(
-        tokenCreator.createERC721("TOS721", "TSA721", { value: fee })
+        tokenCreator.createERC721("TOS721", "TSA721", { value: fee }),
       ).to.emit(tokenCreator, "ERC721Created");
     });
 
     it("should emit ERC1155Created", async () => {
       await expect(
-        tokenCreator.createERC1155("https://myuri", { value: fee })
+        tokenCreator.createERC1155("https://myuri", { value: fee }),
       ).to.emit(tokenCreator, "ERC1155Created");
     });
   });
@@ -56,7 +61,7 @@ describe("TokenCreator", () => {
       await expect(
         tokenCreator.createERC20("TOS", "TSA", 12, 1000, {
           value: hre.ethers.parseEther("0.05"),
-        })
+        }),
       ).to.be.revertedWithCustomError(tokenCreator, "InsufficientFee");
     });
 
@@ -69,51 +74,78 @@ describe("TokenCreator", () => {
 
     it("should transfer the fee when creating an ERC20 token", async () => {
       await checkOwnerBalanceIncrease(() =>
-        tokenCreator.connect(creatorAccount).createERC20("TOS", "TSA", 12, 1000, { value: fee })
+        tokenCreator
+          .connect(creatorAccount)
+          .createERC20("TOS", "TSA", 12, 1000, { value: fee }),
       );
     });
 
     it("should transfer the fee when creating an ERC721 token", async () => {
       await checkOwnerBalanceIncrease(() =>
-        tokenCreator.connect(creatorAccount).createERC721("TOS721", "TSA721", { value: fee })
+        tokenCreator
+          .connect(creatorAccount)
+          .createERC721("TOS721", "TSA721", { value: fee }),
       );
     });
 
     it("should transfer the fee when creating an ERC1155 token", async () => {
       await checkOwnerBalanceIncrease(() =>
-        tokenCreator.connect(creatorAccount).createERC1155("https://myuri", { value: fee })
+        tokenCreator
+          .connect(creatorAccount)
+          .createERC1155("https://myuri", { value: fee }),
       );
     });
   });
 
   describe("Ownership Assignment", () => {
     it("should assign ERC20 token ownership to the creator", async () => {
-      const tx = await tokenCreator.connect(creatorAccount).createERC20("TOS", "TSA", 12, 1000, {
-        value: fee,
-      });
-
-      const tokenAddress = await extractTokenAddressFromEvent(tx, "ERC20Created");
+      const tx = await tokenCreator
+        .connect(creatorAccount)
+        .createERC20("TOS", "TSA", 12, 1000, {
+          value: fee,
+        });
+
+      const tokenAddress = await extractTokenAddressFromEvent(
+        tx,
+        "ERC20Created",
+      );
       const erc20 = await hre.ethers.getContractAt("ERC20Token", tokenAddress);
       expect(await erc20.owner()).to.equal(creatorAccount.address);
     });
 
     it("should assign ERC721 token ownership to the creator", async () => {
-      const tx = await tokenCreator.connect(creatorAccount).createERC721("TOS721", "TSA721", {
-        value: fee,
-      });
-
-      const tokenAddress = await extractTokenAddressFromEvent(tx, "ERC721Created");
-      const erc721 = await hre.ethers.getContractAt("ERC721Token", tokenAddress);
+      const tx = await tokenCreator
+        .connect(creatorAccount)
+        .createERC721("TOS721", "TSA721", {
+          value: fee,
+        });
+
+      const tokenAddress = await extractTokenAddressFromEvent(
+        tx,
+        "ERC721Created",
+      );
+      const erc721 = await hre.ethers.getContractAt(
+        "ERC721Token",
+        tokenAddress,
+      );
       expect(await erc721.owner()).to.equal(creatorAccount.address);
     });
 
     it("should assign ERC1155 token ownership to the creator", async () => {
-      const tx = await tokenCreator.connect(creatorAccount).createERC1155("https://myuri", {
-        value: fee,
-      });
-
-      const tokenAddress = await extractTokenAddressFromEvent(tx, "ERC1155Created");
-      const erc1155 = await hre.ethers.getContractAt("ERC1155Token", tokenAddress);
+      const tx = await tokenCreator
+        .connect(creatorAccount)
+        .createERC1155("https://myuri", {
+          value: fee,
+        });
+
+      const tokenAddress = await extractTokenAddressFromEvent(
+        tx,
+        "ERC1155Created",
+      );
+      const erc1155 = await hre.ethers.getContractAt(
+        "ERC1155Token",
+        tokenAddress,
+      );
       expect(await erc1155.owner()).to.equal(creatorAccount.address);
     });
   });