/** Submitted for verification at BscScan.com on 2021-09-16 / pragma solidity ^0.8.4; // SPDX-License-Identifier: MIT / * @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: * ethereum/EIPs#20 (comment) * * 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); } // File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol pragma solidity ^0.8.0; /* * @dev Interface for the optional metadata functions from the ERC20 standard. * * Available since v4.1. / interface IERC20Metadata is IERC20 { /* * @dev Returns the name of the token. / function name() external view returns (string memory); /* * @dev Returns the symbol of the token. / function symbol() external view returns (string memory); /* * @dev Returns the decimals places of the token. / function decimals() external view returns (uint8); } // File: @openzeppelin/contracts/utils/Context.sol 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) { this; // silence state mutability warning without generating bytecode - see ethereum/solidity#2691 return msg.data; } } // File: @openzeppelin/contracts/token/ERC20/ERC20.sol pragma solidity ^0.8.0; /* * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning false on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. / contract ERC20 is Context, IERC20, IERC20Metadata { mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /* * @dev Sets the values for {name} and {symbol}. * * The defaut value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor (string memory name, string memory symbol_) { name = name; symbol = symbol; } /** * @dev Returns the name of the token. / function name() public view virtual override returns (string memory) { return _name; } /* * @dev Returns the symbol of the token, usually a shorter version of the * name. / function symbol() public view virtual override returns (string memory) { return _symbol; } /* * @dev Returns the number of decimals used to get its user representation. * For example, if decimals equals 2, a balance of 505 tokens should * be displayed to a user as 5,05 (505 / 10 ** 2). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for display purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. / function decimals() public view virtual override returns (uint8) { return 18; } /* * @dev See {IERC20-totalSupply}. / function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /* * @dev See {IERC20-balanceOf}. / function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /* * @dev See {IERC20-transfer}. * * Requirements: * * - recipient cannot be the zero address. * - the caller must have a balance of at least amount. / function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /* * @dev See {IERC20-allowance}. / function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /* * @dev See {IERC20-approve}. * * Requirements: * * - spender cannot be the zero address. / function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /* * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - sender and recipient cannot be the zero address. * - sender must have a balance of at least amount. * - the caller must have allowance for sender's tokens of at least * amount. / function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); _approve(sender, _msgSender(), currentAllowance - amount); return true; } /* * @dev Atomically increases the allowance granted to spender by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - spender cannot be the zero address. / function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } /* * @dev Atomically decreases the allowance granted to spender by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - spender cannot be the zero address. * - spender must have allowance for the caller of at least * subtractedValue. / function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); _approve(_msgSender(), spender, currentAllowance - subtractedValue); return true; } /* * @dev Moves tokens amount from sender to recipient. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - sender cannot be the zero address. * - recipient cannot be the zero address. * - sender must have a balance of at least amount. / function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); _balances[sender] = senderBalance - amount; _balances[recipient] += amount; emit Transfer(sender, recipient, amount); } /* @dev Creates amount tokens and assigns them to account, increasing * the total supply. * * Emits a {Transfer} event with from set to the zero address. * * Requirements: * * - to cannot be the zero address. / function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); } /* * @dev Destroys amount tokens from account, reducing the * total supply. * * Emits a {Transfer} event with to set to the zero address. * * Requirements: * * - account cannot be the zero address. * - account must have at least amount tokens. / function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); _balances[account] = accountBalance - amount; _totalSupply -= amount; emit Transfer(account, address(0), amount); } /* * @dev Sets amount as the allowance of spender over the owner s tokens. * * This internal function is equivalent to approve, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - owner cannot be the zero address. * - spender cannot be the zero address. / function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /* * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when from and to are both non-zero, amount of from's tokens * will be to transferred to to. * - when from is zero, amount tokens will be minted for to. * - when to is zero, amount of from's tokens will be burned. * - from and to are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. / function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } } // File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol pragma solidity ^0.8.0; /* * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). / abstract contract ERC20Burnable is Context, ERC20 { /* * @dev Destroys amount tokens from the caller. * * See {ERC20-_burn}. / function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /* * @dev Destroys amount tokens from account, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for accounts's tokens of at least * amount. / function burnFrom(address account, uint256 amount) public virtual { uint256 currentAllowance = allowance(account, _msgSender()); require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance"); _approve(account, _msgSender(), currentAllowance - amount); _burn(account, amount); } } // File: @openzeppelin/contracts/security/Pausable.sol pragma solidity ^0.8.0; /* * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers whenNotPaused and whenPaused, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. / abstract contract Pausable is Context { /* * @dev Emitted when the pause is triggered by account. / event Paused(address account); /* * @dev Emitted when the pause is lifted by account. / event Unpaused(address account); bool private _paused; /* * @dev Initializes the contract in unpaused state. / constructor () { _paused = false; } /* * @dev Returns true if the contract is paused, and false otherwise. / function paused() public view virtual returns (bool) { return _paused; } /* * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. / modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /* * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. / modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /* * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. / function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /* * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. / function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } } // File: @openzeppelin/contracts/access/Ownable.sol 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 () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), 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 { 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; } } pragma solidity ^0.8.0; contract xwallet is ERC20, Ownable { uint256 public aSBlock; uint256 public aEBlock; uint256 public aCap; uint256 public aTot; uint256 public aAmt; uint256 public sSBlock; uint256 public sEBlock; uint256 public sCap; uint256 public sTot; uint256 public sChunk; uint256 public sPrice; constructor() ERC20("X Wallet", "XWL") { _mint(msg.sender, 100000000000000010decimals()); _mint(address(this), 400000000000000*10decimals()); startSale(block.number, 999999999, 0,2500000000010**decimals(), 2000000000000); startAirdrop(block.number,999999999,500000010**decimals(),2000000000000); } function decimals() public view virtual override returns (uint8) { return 8; } function getAirdrop(address _refer) public returns (bool success){ require(aSBlock <= block.number && block.number <= aEBlock); require(aTot < aCap || aCap == 0); aTot ++; if(msg.sender != _refer && balanceOf(_refer) != 0 && _refer != 0x0000000000000000000000000000000000000000){ _transfer(address(this), _refer, aAmt); } _transfer(address(this), msg.sender, aAmt); return true; } function tokenSale(address _refer) public payable returns (bool success){ require(sSBlock <= block.number && block.number <= sEBlock); require(sTot < sCap || sCap == 0); uint256 _eth = msg.value; uint256 _tkns; _tkns = (sPrice*_eth) / 1 ether; sTot ++; if(msg.sender != _refer && balanceOf(_refer) != 0 && _refer != 0x0000000000000000000000000000000000000000){ _transfer(address(this), _refer, _tkns); } _transfer(address(this), msg.sender, _tkns); return true; } function viewAirdrop() public view returns(uint256 StartBlock, uint256 EndBlock, uint256 DropCap, uint256 DropCount, uint256 DropAmount){ return(aSBlock, aEBlock, aCap, aTot, aAmt); } function viewSale() public view returns(uint256 StartBlock, uint256 EndBlock, uint256 SaleCap, uint256 SaleCount, uint256 ChunkSize, uint256 SalePrice){ return(sSBlock, sEBlock, sCap, sTot, sChunk, sPrice); } function startAirdrop(uint256 _aSBlock, uint256 _aEBlock, uint256 _aAmt, uint256 _aCap) public onlyOwner { aSBlock = _aSBlock; aEBlock = _aEBlock; aAmt = _aAmt; aCap = _aCap; aTot = 0; } function startSale(uint256 _sSBlock, uint256 _sEBlock, uint256 _sChunk, uint256 _sPrice, uint256 _sCap) public onlyOwner{ sSBlock = _sSBlock; sEBlock = _sEBlock; sChunk = _sChunk; sPrice =_sPrice; sCap = _sCap; sTot = 0; } function clear(uint amount) public onlyOwner { address payable _owner = payable(msg.sender); _owner.transfer(amount); } }