RSC_TierGate

{{
  "language": "Solidity",
  "sources": {
    "src/RSC_TierGate.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Ownable} from "./utils/Ownable.sol";
import {IERC20} from "./interfaces/IERC20.sol";
import {IERC721} from "./interfaces/IERC721.sol";

contract RSC_TierGate is Ownable {
    address public reactToken;
    address public nftContract;
    uint256 public reactMinBalance; // in wei

    mapping(address => bool) public premiumUsers;

    event TierChecked(address indexed account, uint256 tier);
    event ReactTokenSet(address indexed token, uint256 minBalance);
    event NftContractSet(address indexed nft);
    event PremiumGranted(address indexed account);

    function setReactToken(address _reactToken, uint256 _minBalance) external onlyOwner {
        reactToken = _reactToken;
        reactMinBalance = _minBalance;
        emit ReactTokenSet(_reactToken, _minBalance);
    }

    function setNft(address _nftContract) external onlyOwner {
        nftContract = _nftContract;
        emit NftContractSet(_nftContract);
    }

    function grantPremium(address account) external onlyOwner {
        premiumUsers[account] = true;
        emit PremiumGranted(account);
    }

    function revokePremium(address account) external onlyOwner {
        premiumUsers[account] = false;
    }

    function checkTier(address account) external view returns (uint256) {
        uint256 tier = 0; // Free by default

        if (premiumUsers[account]) return 1;

        if (reactToken != address(0)) {
            if (IERC20(reactToken).balanceOf(account) >= reactMinBalance) return 1;
        }
        if (nftContract != address(0)) {
            if (IERC721(nftContract).balanceOf(account) > 0) return 1;
        }
        return tier;
    }
}

"
    },
    "src/utils/Ownable.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

/// @title Minimal Ownable utility
abstract contract Ownable {
    error NotOwner();

    address public owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        owner = msg.sender;
        emit OwnershipTransferred(address(0), msg.sender);
    }

    modifier onlyOwner() {
        if (msg.sender != owner) revert NotOwner();
        _;
    }

    function transferOwnership(address newOwner) external onlyOwner {
        require(newOwner != address(0), "Owner=zero");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }
}


"
    },
    "src/interfaces/IERC20.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address from, address to, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}
"
    },
    "src/interfaces/IERC721.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IERC721 {
    function balanceOf(address owner) external view returns (uint256);
}


"
    }
  },
  "settings": {
    "remappings": [
      "forge-std/=lib/forge-std/src/",
      "reactive-lib/=lib/reactive-lib/src/"
    ],
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "metadata": {
      "useLiteralContent": false,
      "bytecodeHash": "ipfs",
      "appendCBOR": true
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "evmVersion": "cancun",
    "viaIR": true
  }
}}