with 💕

Author: minion

contracts_bscscan/testnet/00/00874A13DC217bB72D6a9CDEbF5710603734e9Cb_Whitelist.sol

@@ -0,0 +1,120 @@
+/**
+ *Submitted for verification at BscScan.com on 2022-01-27
+*/
+
+/**
+ *Develop by CPTRedHawk
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+pragma solidity ^0.8.11;
+
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        return msg.data;
+    }
+}
+
+abstract contract Ownable is Context {
+    address private _owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    /**
+     * @dev Initializes the contract setting the deployer as the initial owner.
+     */
+    constructor() {
+        _transferOwnership(_msgSender());
+    }
+
+    /**
+     * @dev Returns the address of the current owner.
+     */
+    function owner() public view virtual returns (address) {
+        return _owner;
+    }
+
+    /**
+     * @dev Throws if called by any account other than the owner.
+     */
+    modifier onlyOwner() {
+        require(owner() == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    /**
+     * @dev Leaves the contract without owner. It will not be possible to call
+     * `onlyOwner` functions anymore. Can only be called by the current owner.
+     *
+     * NOTE: Renouncing ownership will leave the contract without an owner,
+     * thereby removing any functionality that is only available to the owner.
+     */
+    function renounceOwnership() public virtual onlyOwner {
+        _transferOwnership(address(0));
+    }
+
+    /**
+     * @dev Transfers ownership of the contract to a new account (`newOwner`).
+     * Can only be called by the current owner.
+     */
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), "Ownable: new owner is the zero address");
+        _transferOwnership(newOwner);
+    }
+
+    /**
+     * @dev Transfers ownership of the contract to a new account (`newOwner`).
+     * Internal function without access restriction.
+     */
+    function _transferOwnership(address newOwner) internal virtual {
+        address oldOwner = _owner;
+        _owner = newOwner;
+        emit OwnershipTransferred(oldOwner, newOwner);
+    }
+}
+
+contract Whitelist is Ownable  {
+    
+
+    uint256 private withdrawableBalance;
+    address[] public whitelister;
+
+    mapping(address => bool) whitelistedAddresses;
+
+
+    modifier isWhitelisted(address _address) {
+      require(whitelistedAddresses[_address], "Whitelist: You need to be whitelisted");
+      _;
+    }
+
+    function addUser(address _addressToWhitelist) external onlyOwner {
+      whitelistedAddresses[_addressToWhitelist] = true;
+    }
+
+    function verifyUser(address _whitelistedAddress) public view returns(bool) {
+      bool userIsWhitelisted = whitelistedAddresses[_whitelistedAddress];
+      return userIsWhitelisted;
+    }
+
+
+
+
+    function withdrawLockedBNB(address payable to) external onlyOwner() {
+        withdrawableBalance = address(this).balance;
+        uint256 amount = withdrawableBalance;
+        withdrawableBalance = 0;
+        to.transfer(amount);
+       
+    }
+
+    function enter() public isWhitelisted(msg.sender) payable {
+        require(msg.value > 1 ether);
+        whitelister.push(msg.sender);
+    }
+
+}