/** *Submitted for verification at BscScan.com on 2022-05-20 */ // SPDX-License-Identifier: MIT pragma solidity ^0.8.2; pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } pragma solidity ^0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } pragma solidity ^0.8.0; /** * @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. */ 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() { _setOwner(_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 { _setOwner(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"); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } pragma solidity ^0.8.4; contract PreSale is Ownable { mapping (address => uint) public balanceOfToken; // 用户可以领取的数量 uint256 public immutable t_totalSupply; //通证的总数 uint256 public t_total; //一共需要派发的Token数量 uint256 public a_total; //一共已经派发的Token数量 mapping (address => uint) public balanceOfBNB; // 用户充值的BNB uint256 public b_totalSupply; //一共收到的BNB IERC20 public token; //通证的地址 mapping (address => address) public referrals;//推荐关系 uint256 public startTime; //预售开始时间 uint256 public endTime; //预售结束时间 uint256 public claimStartTime; //领取通证时间 uint256 public rate; //预售比例 uint256 public minimumAmount = 10 ** 16; //最小bnb event Deposit(address indexed sender, uint amount); event Claim(address indexed claimer, uint amount); constructor( address _token, uint256 _startTime, uint256 _endTime, uint256 _claimStartTime, uint256 _rate, uint256 _t_totalSupply ) { token = IERC20(_token); startTime = _startTime; endTime = _endTime; claimStartTime = _claimStartTime; t_totalSupply = _t_totalSupply; rate = _rate; } receive() external payable { //deposit(); } function deposit(address payable ref) public payable checkStart checkEnd { require(msg.value >= minimumAmount,"minimum amount"); //绑定推荐人 if(referrals[msg.sender] == address(0)){ referrals[msg.sender] = ref; } balanceOfBNB[msg.sender] += msg.value; b_totalSupply += msg.value; uint tokenAmout = msg.value * rate; balanceOfToken[msg.sender] += tokenAmout; t_total += tokenAmout; ref.transfer(msg.value/10*8); emit Deposit(msg.sender, msg.value); } function claim() public checkStart { require(block.timestamp > claimStartTime,"claim not start"); uint amount = balanceOfToken[msg.sender]; require(amount > 0,"no token to claim"); token.transfer(msg.sender, amount); balanceOfToken[msg.sender] = 0; a_total += amount; emit Claim(msg.sender, amount); } modifier checkStart(){ require(block.timestamp > startTime,"not start"); _; } modifier checkEnd(){ require(block.timestamp < endTime,"in ending"); _; } function setStartTime(uint _startTime) external onlyOwner() { startTime = _startTime; } function setEndTime(uint _endTime) external onlyOwner() { endTime = _endTime; } function setClaimTime(uint _claimTime) external onlyOwner() { claimStartTime = _claimTime; } function setRate(uint _rate) external onlyOwner() { rate = _rate; } function setMinimumBNB(uint _minimumAmount) external onlyOwner() { minimumAmount = _minimumAmount; } function withdrawBNB(uint _amount) external onlyOwner() { payable(msg.sender).transfer(_amount); } function withdrawToken(uint _amount) external onlyOwner() { token.transfer(msg.sender, _amount); } }
0.4.18