refactor: factory owns VRF subscription — eliminate manual subId setup

- Introduce ILotteryEvents interface for clean event definitions
- Remove subId from factory constructor and deploy script
- Factory now creates subscription on deployment (permanent ownership)
- No pre-created subscription or ownership transfer needed
- Simplifies deployment and removes mainnet friction

This aligns with production patterns (PoolTogether, Gelato) — factory owns sub, unlimited lotteries

Author: tr-Kalyan

broadcast/DeployLotteryFactory.s.sol/11155111/run-1765133759257.json

@@ -2,7 +2,9 @@
 src = "src"
 out = "out"
 libs = ["lib"]
- 
-
+solc = "0.8.20"
+optimizer = true         
+optimizer_runs = 200     
+via_ir = false
 
 # See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options

broadcast/DeployLotteryFactory.s.sol/11155111/run-1765133849790.json

@@ -65,9 +65,6 @@ contract LotteryFactory is Ownable {
         lotteryAddress = address(newLottery);
         allLotteries.push(lotteryAddress);
 
-        // Auto-accept ownership of lottery on behalf of caller
-        // newLottery.acceptOwnership();
-
 
         // Factory (subscription owner) adds lottery as consumer
         vrfCoordinator.addConsumer(vrfSubscriptionId, lotteryAddress);
@@ -78,7 +75,7 @@ contract LotteryFactory is Ownable {
 
     /// @notice Fund the factory-owned subscription with LINK
     /// @param amount Amount of LINK to add (in wei)
-    function fundSubscription(uint256 amount) external {
+    function fundSubscription(uint256 amount) external onlyOwner{
         // 1. Pull LINK from caller → factory
         LinkTokenInterface(linkToken).transferFrom(msg.sender, address(this), amount);
 
@@ -98,4 +95,10 @@ contract LotteryFactory is Ownable {
     function getAllLotteries() external view returns (address[] memory) {
         return allLotteries;
     }
+
+    /// @notice Remove a lottery from the VRF subscription to free a consumer slot
+    /// @param lotteryAddress Address of the finished lottery
+    function removeConsumer(address lotteryAddress) external onlyOwner {
+        vrfCoordinator.removeConsumer(vrfSubscriptionId, lotteryAddress);
+    }
 }

broadcast/DeployLotteryFactory.s.sol/11155111/run-1765135172560.json

@@ -7,13 +7,13 @@ import {AutomationCompatibleInterface} from "@chainlink/automation/AutomationCom
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
-
+import {ILotteryEvents} from "./interfaces/ILotteryEvents.sol";
 
 /// @title Gas-Optimized Weighted Lottery with Chainlink VRF v2.5 & Automation
 /// @author Security Researcher
 /// @notice Fully autonomous lottery using cumulative sum pattern for O(1) entry and weighted randomness
 /// @dev Factory deploys this contract — subscription owned by factory — all fees go to owner
-contract Lottery is VRFConsumerBaseV2Plus, AutomationCompatibleInterface, ReentrancyGuard {
+contract Lottery is ILotteryEvents, VRFConsumerBaseV2Plus, AutomationCompatibleInterface, ReentrancyGuard {
     using SafeERC20 for IERC20;
 
     /*//////////////////////////////////////////////////////////////
@@ -62,12 +62,7 @@ contract Lottery is VRFConsumerBaseV2Plus, AutomationCompatibleInterface, Reentr
                                    EVENTS
     //////////////////////////////////////////////////////////////*/
 
-    event Entered(address indexed player, uint256 tickets, uint256 rangeStart, uint256 rangeEnd);
-    event WinnerPicked(address indexed winner, uint256 prizeAmount, uint256 winningTicketId);
-    event AutoWinTriggered(address indexed winner, uint256 prizeAmount);
-    event FeesDistributed(uint256 amount);
-    event LotteryClosed(uint256 indexed requestId);
-    event LotteryStateRecovered(uint256 timestamp);
+
 
     /*//////////////////////////////////////////////////////////////
                                   CONSTRUCTOR

broadcast/DeployLotteryFactory.s.sol/11155111/run-1765136821985.json

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+interface ILotteryEvents {
+    event Entered(address indexed player, uint256 tickets, uint256 rangeStart, uint256 rangeEnd);
+    event WinnerPicked(address indexed winner, uint256 prizeAmount, uint256 winningTicketId);
+    event AutoWinTriggered(address indexed winner, uint256 prizeAmount);
+    event FeesDistributed(uint256 amount);
+    event LotteryClosed(uint256 indexed requestId); // Indexed for easier searching
+    event LotteryStateRecovered(uint256 timestamp);
+}

broadcast/DeployLotteryFactory.s.sol/11155111/run-latest.json

@@ -9,8 +9,8 @@ import {VRFCoordinatorV2_5Mock} from "@chainlink/vrf/mocks/VRFCoordinatorV2_5Moc
 import {MockLinkToken} from "@chainlink/mocks/MockLinkToken.sol";
 import {MockUSDC} from "./mock/MockUSDC.sol"; 
 import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-
-contract LotteryTest is Test {
+import {ILotteryEvents} from "../src/interfaces/ILotteryEvents.sol";
+contract LotteryTest is Test, ILotteryEvents {
     LotteryFactory public factory;
     Lottery public lottery;
     VRFCoordinatorV2_5Mock public vrfMock;
@@ -119,12 +119,14 @@ contract LotteryTest is Test {
         uint256 balanceBefore = usdc.balanceOf(player1);
 
         vm.expectEmit(true, true, false, true);
-        emit Lottery.Entered(
-            player1,
-            tickets,
-            0,      // rangeStart (first entry = 0)
-            9      // rangeEnd (0 + 10)
-        );
+        // emit Lottery.Entered(
+        //     player1,
+        //     tickets,
+        //     0,      // rangeStart (first entry = 0)
+        //     9      // rangeEnd (0 + 10)
+        // );
+
+        emit Entered(player1,tickets,0,9);
 
         vm.prank(player1);
         lottery.enter(tickets);
@@ -500,4 +502,53 @@ contract LotteryTest is Test {
         vm.prank(player1);
         factory.createLottery(1e6, address(usdc), 100, 1 hours, 500_000, 1 hours);
     }
+
+    function test_21_RemoveConsumerFreesSlotAndAllowsNewLottery() public {
+        // === Fill up to 99 lotteries (max consumers) ===
+        // === Mock counts owner(factory) as consumer ===
+        for (uint i = 0; i < 99; i++) {
+            vm.prank(owner);
+            factory.createLottery(
+                TICKET_PRICE,
+                address(usdc),
+                MAX_TICKETS,
+                DURATION,
+                500_000,
+                1 hours
+            );
+        }
+
+        // === Try to create 100th lottery → should REVERT (no consumer slot) ===
+        vm.expectRevert(); // Chainlink: "Too many consumers"
+        vm.prank(owner);
+        factory.createLottery(
+            TICKET_PRICE,
+            address(usdc),
+            MAX_TICKETS,
+            DURATION,
+            500_000,
+            1 hours
+        );
+
+        // === Get the first lottery address ===
+        address[] memory Lotteries = factory.getAllLotteries();
+        address firstLottery = Lotteries[0];
+
+        // === Remove it as consumer ===
+        vm.prank(owner);
+        factory.removeConsumer(firstLottery);
+
+        // === Now create 101th lottery → should PASS ===
+        vm.prank(owner);
+        address newLottery = factory.createLottery(
+            TICKET_PRICE,
+            address(usdc),
+            MAX_TICKETS,
+            DURATION,
+            500_000,
+            1 hours
+        );
+
+        assertTrue(newLottery != address(0), "100th lottery created after removal");
+    }
 }