Created
October 23, 2021 03:03
-
-
Save bankrollnetwork/941a8135e4a30353a514c29d2df2998e to your computer and use it in GitHub Desktop.
Created using remix-ide: Realtime Ethereum Contract Compiler and Runtime. Load this file by pasting this gists URL or ID at https://remix.ethereum.org/#version=soljson-v0.6.12+commit.27d51765.js&optimize=true&runs=200&gist=
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
pragma solidity ^0.6.8; | |
/* | |
SPDX-License-Identifier: MIT | |
A Bankteller Production | |
Bankroll Network | |
Copyright 2021 | |
*/ | |
abstract contract Context { | |
function _msgSender() internal view virtual returns (address payable) { | |
return msg.sender; | |
} | |
function _msgData() internal view virtual returns (bytes memory) { | |
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 | |
return msg.data; | |
} | |
} | |
/** | |
* @dev Contract module which provides a basic access control mechanism, where | |
* there is an account (an owner) that can be granted exclusive access to | |
* specific functions. | |
* | |
* By default, the owner account will be the one that deploys the contract. This | |
* can later be changed with {transferOwnership}. | |
* | |
* This module is used through inheritance. It will make available the modifier | |
* `onlyOwner`, which can be applied to your functions to restrict their use to | |
* the owner. | |
*/ | |
contract Ownable is Context { | |
address private _owner; | |
address private _previousOwner; | |
uint256 private _lockTime; | |
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); | |
/** | |
* @dev Initializes the contract setting the deployer as the initial owner. | |
*/ | |
constructor () internal { | |
address msgSender = _msgSender(); | |
_owner = msgSender; | |
emit OwnershipTransferred(address(0), msgSender); | |
} | |
/** | |
* @dev Returns the address of the current owner. | |
*/ | |
function owner() public view 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 { | |
emit OwnershipTransferred(_owner, address(0)); | |
_owner = 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"); | |
emit OwnershipTransferred(_owner, newOwner); | |
_owner = newOwner; | |
} | |
function getUnlockTime() public view returns (uint256) { | |
return _lockTime; | |
} | |
//Locks the contract for owner for the amount of time provided | |
function lock(uint256 time) public virtual onlyOwner { | |
_previousOwner = _owner; | |
_owner = address(0); | |
_lockTime = now + time; | |
emit OwnershipTransferred(_owner, address(0)); | |
} | |
//Unlocks the contract for owner when _lockTime is exceeds | |
function unlock() public virtual { | |
require(_previousOwner == msg.sender, "You don't have permission to unlock"); | |
require(now > _lockTime , "Contract is locked until 7 days"); | |
emit OwnershipTransferred(_owner, _previousOwner); | |
_owner = _previousOwner; | |
} | |
} | |
/** | |
* @title Whitelist | |
* @dev The Whitelist contract has a whitelist of addresses, and provides basic authorization control functions. | |
* @dev This simplifies the implementation of "user permissions". | |
*/ | |
contract Whitelist is Ownable { | |
mapping(address => bool) public whitelist; | |
event WhitelistedAddressAdded(address addr); | |
event WhitelistedAddressRemoved(address addr); | |
/** | |
* @dev Throws if called by any account that's not whitelisted. | |
*/ | |
modifier onlyWhitelisted() { | |
require(whitelist[msg.sender], 'not whitelisted'); | |
_; | |
} | |
/** | |
* @dev add an address to the whitelist | |
* @param addr address | |
* @return success true if the address was added to the whitelist, false if the address was already in the whitelist | |
*/ | |
function addAddressToWhitelist(address addr) onlyOwner public returns(bool success) { | |
if (!whitelist[addr]) { | |
whitelist[addr] = true; | |
emit WhitelistedAddressAdded(addr); | |
success = true; | |
} | |
} | |
/** | |
* @dev add addresses to the whitelist | |
* @param addrs addresses | |
* @return success true if at least one address was added to the whitelist, | |
* false if all addresses were already in the whitelist | |
*/ | |
function addAddressesToWhitelist(address[] calldata addrs) onlyOwner public returns(bool success) { | |
for (uint256 i = 0; i < addrs.length; i++) { | |
if (addAddressToWhitelist(addrs[i])) { | |
success = true; | |
} | |
} | |
} | |
/** | |
* @dev remove an address from the whitelist | |
* @param addr address | |
* @return success true if the address was removed from the whitelist, | |
* false if the address wasn't in the whitelist in the first place | |
*/ | |
function removeAddressFromWhitelist(address addr) onlyOwner public returns(bool success) { | |
if (whitelist[addr]) { | |
whitelist[addr] = false; | |
emit WhitelistedAddressRemoved(addr); | |
success = true; | |
} | |
} | |
/** | |
* @dev remove addresses from the whitelist | |
* @param addrs addresses | |
* @return success true if at least one address was removed from the whitelist, | |
* false if all addresses weren't in the whitelist in the first place | |
*/ | |
function removeAddressesFromWhitelist(address[] calldata addrs) onlyOwner public returns(bool success) { | |
for (uint256 i = 0; i < addrs.length; i++) { | |
if (removeAddressFromWhitelist(addrs[i])) { | |
success = true; | |
} | |
} | |
} | |
} | |
interface IToken { | |
function transfer(address to, uint256 value) external returns (bool); | |
} | |
contract Treasury is Whitelist { | |
IToken public token; // address of the BEP20 token traded on this contract | |
//There can be a general purpose treasury for any BEP20 token | |
constructor(address token_addr) public Ownable() { | |
token = IToken(token_addr); | |
} | |
function withdraw(uint256 _amount) public onlyWhitelisted { | |
require(token.transfer(_msgSender(), _amount)); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment