Implement Chip ERC20 token and Roulette game base

Replaces AccessControl with Ownable, Pausable, and ERC20 in Chip.sol, adding mint, burn, blacklist, and pause functionality. Introduces a new Roulette.sol contract with Chainlink VRF integration, round management, and initial configuration for a roulette game.

Author: Timmy-Lane

src/Chip.sol

@@ -1,10 +1,64 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.24;
 
-import "@openzeppelin/contracts/access/AccessControl.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/utils/Pausable.sol";
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 
-contract Chip{
-    constructor(){
+contract Chip is ERC20, Ownable, Pausable {
+    mapping(address => bool) blacklist;
 
+    event Blacklisted(address indexed account, bool isBlacklisted);
+    event Minted(address indexed to, uint256 amount);
+    event Burned(address indexed from, uint256 amount);
+
+    modifier notBlacklisted(address account) {
+        require(!blacklist[account], "CHIP: address is blacklisted");
+        _;
+    }
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address initialOwner
+    ) ERC20(_name, _symbol) Ownable(initialOwner) {}
+
+    function mint(address to, uint256 amount) external onlyOwner {
+        _mint(to, amount);
+        emit Minted(to, amount);
+    }
+
+    function burn(address from, uint256 amount) external onlyOwner {
+        _burn(from, amount);
+        emit Burned(from, amount);
+    }
+
+    function _update(
+        address to,
+        address from,
+        uint256 value
+    ) internal override whenNotPaused notBlacklisted(from) notBlacklisted(to) {
+        super._update(from, to, value);
+    }
+
+    function setBlacklist(address account, bool value) external onlyOwner {
+        blacklist[account] = value;
+        emit Blacklisted(account, value);
+    }
+
+    function unpause() external onlyOwner {
+        _unpause();
+    }
+
+    function pause() external onlyOwner {
+        _pause();
+    }
+
+    receive() external payable {
+        revert("No ether accepted");
+    }
+
+    fallback() external payable {
+        revert("No ether accepted");
     }
 }

src/games/Roulette.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.30;
+
+import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "@chainlink/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol";
+import "@chainlink/contracts/src/v0.8/vrf/interfaces/VRFCoordinatorV2Interface.sol";
+
+contract Roulette is Ownable, ReentrancyGuard, VRFConsumerBaseV2 {
+    VRFCoordinatorV2Interface public coordinator;
+    bytes32 public keyHash;
+    uint64 public subId;
+    uint32 public callbackGasLimit = 250_000;
+    uint16 public reqConfirmations = 3;
+
+    uint256 public ticketPrice;
+    uint256 public creatorFeeBase;
+    uint256 public currentRoundId;
+
+    constructor(
+        uint256 _ticketPrice,
+        uint256 _creatorFeeBase,
+        address _vrfCoordinator,
+        bytes32 _keyHash,
+        uint64 _subscriptionId
+    ) Ownable(msg.sender) VRFConsumerBaseV2(_vrfCoordinator) {
+        require(_creatorFeeBase <= 2000, "creator fee too high");
+        ticketPrice = _ticketPrice;
+        creatorFeeBase = _creatorFeeBase;
+
+        coordinator = VRFCoordinatorV2Interface(_vrfCoordinator);
+        keyHash = _keyHash;
+        subId = _subscriptionId;
+
+        _startNewRound();
+    }
+
+    function _startNewRound() internal {}
+}