Added Factory functionality

Author: VorobevSA

contracts/RaffleFactory.sol

@@ -1,20 +1,68 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.28;
 
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
-import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
+import "./RaffleNFT.sol";
+
+contract RaffleFactory is Initializable, UUPSUpgradeable, AccessControlUpgradeable, ReentrancyGuardUpgradeable {
+    bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
+    address[] public raffles;
+
+    event RaffleCreated(address indexed raffleAddress, address indexed creator);
 
-contract RaffleFactory is Initializable, UUPSUpgradeable, OwnableUpgradeable {
     /// @custom:oz-upgrades-unsafe-allow constructor
     constructor() {
         _disableInitializers();
     }
 
     function initialize() public initializer {
-        __Ownable_init(msg.sender);
         __UUPSUpgradeable_init();
+        __AccessControl_init();
+        __ReentrancyGuard_init();
+        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
+    }
+
+    function _authorizeUpgrade(address newImplementation) internal override onlyAdmin {}
+
+    modifier onlyManager() {
+        require(hasRole(MANAGER_ROLE, msg.sender), "Not manager");
+        _;
+    }
+
+    modifier onlyAdmin() {
+        require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "Not admin");
+        _;
     }
 
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
+    // Reentrancy guarded via `nonReentrant` modifier
+    // slither-disable-next-line reentrancy-benign
+    function createRaffle(
+        string memory name_,
+        string memory symbol_,
+        string memory tokenURI_,
+        address prizeToken,
+        uint256 amount
+    ) external onlyManager nonReentrant returns (address) {
+        // Transfer tokens from user to factory
+        require(
+            IERC20(prizeToken).transferFrom(msg.sender, address(this), amount),
+            "Token transfer to factory failed"
+        );
+        // Deploy RaffleNFT
+        RaffleNFT raffle = new RaffleNFT(name_, symbol_, tokenURI_);
+        raffles.push(address(raffle));
+        // Approve RaffleNFT to spend tokens
+        require(
+            IERC20(prizeToken).approve(address(raffle), amount),
+            "Approve to raffle failed"
+        );
+        // Start the raffle (transfer tokens to the contract)
+        raffle.startRaffle(prizeToken, amount);
+        emit RaffleCreated(address(raffle), msg.sender);
+        return address(raffle);
+    }
 }

contracts/RaffleNFT.sol

@@ -2,7 +2,40 @@
 pragma solidity ^0.8.28;
 
 import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
 
-contract RaffleNFT is ERC721 {
-    constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_) {}
+contract RaffleNFT is ERC721, ReentrancyGuard {
+    address public prizeToken;
+    uint256 public amount;
+    bool public started;
+    string private baseTokenURI;
+
+    constructor(
+        string memory name_,
+        string memory symbol_,
+        string memory tokenURI_
+    ) ERC721(name_, symbol_) {
+        baseTokenURI = tokenURI_;
+        started = false;
+    }
+
+    function startRaffle(
+        address prizeToken_,
+        uint256 amount_
+    ) external nonReentrant {
+        require(prizeToken_ != address(0), "Zero address");
+        require(!started, "Already started");
+        started = true;
+        prizeToken = prizeToken_;
+        amount = amount_;
+        require(
+            IERC20(prizeToken).transferFrom(msg.sender, address(this), amount),
+            "ERC20 transfer failed"
+        );
+    }
+
+    function tokenURI(uint256) public view override returns (string memory) {
+        return baseTokenURI;
+    }
 }

contracts/test/ERC20.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract ERC20TestToken is ERC20 {
+    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) {}
+
+    function mint(address to, uint256 amount) public {
+        _mint(to, amount);
+    }
+} 

test/Factory.js

@@ -12,8 +12,70 @@ describe("Factory", function () {
 
     // Deploy RaffleNFT (not upgradeable)
     const RaffleNFT = await ethers.getContractFactory("RaffleNFT");
-    const nft = await RaffleNFT.deploy("TestNFT", "TNFT");
+    const nft = await RaffleNFT.deploy("TestNFT", "TNFT", "https://example.com/metadata.json");
     await nft.waitForDeployment();
     expect(nft.target).to.properAddress;
   });
 });
+
+describe("RaffleFactory full flow", function () {
+  it("Should deploy ERC20, RaffleFactory, and create Raffle via factory with correct checks", async function () {
+    const [owner, manager] = await ethers.getSigners();
+
+    // Deploy test ERC20 token
+    const ERC20TestToken = await ethers.getContractFactory("ERC20TestToken", manager);
+
+    const erc20 = await ERC20TestToken.deploy("TestToken", "TTK");
+    await erc20.waitForDeployment();
+    expect(erc20.target).to.properAddress;
+
+    // Mint tokens to manager
+    await erc20.mint(manager.address, 1000);
+    expect(await erc20.balanceOf(manager.address)).to.equal(1000);
+
+    // Deploy RaffleFactory as UUPS proxy (owner)
+    const RaffleFactory = await ethers.getContractFactory("RaffleFactory", owner);
+    const factory = await upgrades.deployProxy(RaffleFactory, [], { kind: "uups" });
+    await factory.waitForDeployment();
+    expect(factory.target).to.properAddress;
+
+    // Grant MANAGER_ROLE to manager
+    const MANAGER_ROLE = await factory.MANAGER_ROLE();
+    await factory.grantRole(MANAGER_ROLE, manager.address);
+    expect(await factory.hasRole(MANAGER_ROLE, manager.address)).to.be.true;
+
+    // Manager approves factory to spend tokens
+    await erc20.connect(manager).approve(factory.target, 500);
+    expect(await erc20.allowance(manager.address, factory.target)).to.equal(500);
+
+    // Manager creates a new Raffle
+    const tokenURI = "https://example.com/metadata.json";
+    const tx = await factory.connect(manager).createRaffle(
+      "TestRaffle",
+      "TRFL",
+      tokenURI,
+      erc20.target,
+      500
+    );
+    const receipt = await tx.wait();
+
+    // Check event
+    const event = receipt.logs.find(l => l.fragment && l.fragment.name === "RaffleCreated");
+    expect(event).to.exist;
+    const raffleAddress = event.args.raffleAddress;
+    expect(raffleAddress).to.properAddress;
+
+    // Check balances
+    expect(await erc20.balanceOf(manager.address)).to.equal(500);
+    expect(await erc20.balanceOf(factory.target)).to.equal(0);
+    expect(await erc20.balanceOf(raffleAddress)).to.equal(500);
+
+    // Check RaffleNFT state
+    const RaffleNFT = await ethers.getContractFactory("RaffleNFT");
+    const raffle = await RaffleNFT.attach(raffleAddress);
+    expect(await raffle.prizeToken()).to.equal(erc20.target);
+    expect(await raffle.amount()).to.equal(500);
+    expect(await raffle.started()).to.be.true;
+    expect(await raffle.tokenURI(0)).to.equal(tokenURI);
+  });
+});