Contract 0xb4abf001ec05a146696722eb50ca22763deec9a3

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xb5be48d21eb6f83f18cbb76173ba584870d0160cc1ededee1c18006948b67ec9Approve131553732021-12-03 9:24:579 hrs 55 mins ago0x5eede1c45e4401d7d95e55446dad71b511328534 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0000725
0xf7d8fec9ac331a8369282623b7504e7c465935e9beb40b6ece268d30bf3dda37Transfer131346102021-12-02 15:57:441 day 3 hrs ago0x3de6d85f42b33db49bf3386365c34549320b334e IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000181005
0xa1012d94ef7b3a8326462f739a43e304ce0a3cbb93c0ac8578fd8de2c56542ccApprove130300012021-11-28 18:13:165 days 1 hr ago0x448c450beef1ec4dca4f2c5086a381b97ea91f80 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000125915
0xbeb0bf7266d9745d9773620a8b8d0a455aebf71eb8b8cf7b23ef88d9f041f8d3Approve130299862021-11-28 18:12:285 days 1 hr ago0x448c450beef1ec4dca4f2c5086a381b97ea91f80 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0xbaf8c2ed0f7d51feae5a2fa244772b211ad042fa0cb19c8bb786c2741b28b8ccApprove130130252021-11-28 3:02:565 days 16 hrs ago0x4a3e5477b96286ef62120ceefb46ecdf352b634e IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0x04bc57dac77b4034fd0e099c453fa348ab67e9594d72e3c2cdea47abc1bb8366Transfer129203802021-11-24 15:03:389 days 4 hrs ago0xdf984a021d0f615813d122e275aec819025b0955 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000106065
0x56f4acbd3a9771612fbdbe879393dae94543437d3f56b89aa3e1ba630f4f1b21Approve128979502021-11-23 19:36:369 days 23 hrs ago0x75433f4fb125e3f793017614b80c8aafa947c8a5 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0x0f675b86c3bfa32b6ae4441dad978a8439dee20e81f588468bc8508233939a67Approve128785532021-11-23 2:43:4710 days 16 hrs ago0xdd0516301b25327f56d7aa8f6e3357163a308ef3 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0xc9607be1e56d9d9ea5d31999a2666cb891e86ab04c2cb1667b605d88b8c0b960Approve128311892021-11-21 10:06:1812 days 9 hrs ago0xf09bfba0a16357041cab2d7bdf25d484fcdb5f03 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0x780789ef69d4297cdf957e8a25e7551239835623773d025043beecfcae232c30Approve127961272021-11-20 4:06:5913 days 15 hrs ago0xd06a56e1ca79fd6cab8b7491b5f096c1beb7e6aa IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0x011ddc4dcd01d92cfacec7996e28a2acb9daa70f316b150b60d7937e0453c1fdApprove126313422021-11-14 3:26:5119 days 15 hrs ago0x17701bb26983f24beb7987fcd76ec602b6da1dc8 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0x76c87cb8fac5cc7c80997f362163e828c043b992c7384bd4a42bd8b4ea59a56bApprove126103922021-11-13 9:32:1420 days 9 hrs ago0x9fd3174fe380591837047ccc0be7ac24b1ea9772 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0000725
0x478f8628099d8f1942a2f9ef3e624e80794f156aec06b3b25bb4cead4a718e06Approve125645892021-11-11 18:12:0722 days 1 hr ago0xc7c6a65ea4f1d24aad02747801d7aed66d4b151e IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0000725
0x72b0509756601ba7701c0a9174c64714da16bff6c4569ea948912c0dfa01da8aApprove125644672021-11-11 18:05:2922 days 1 hr ago0x120fe6a6c044c3b9d36a2a8e063cb7114f0e12f6 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0xffbff8d1a79824b29f5e06eb88e4ab74a35529a9d3788ec60337076eb3c7cdc8Approve124550802021-11-07 20:45:0725 days 22 hrs ago0x4b975803c3685ef889e0bb388b72c9a39eca411b IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0000725
0x2a0b484e36931d905aa0e48f789107b4012dca5074c74fcf028a73e8237f8f1bApprove124381942021-11-07 6:35:3726 days 12 hrs ago0x5f8520ee89ebbe3226b7167cc9bd7168c2c405a0 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0000725
0x47106e86986385e9eda8ae4d7d31537a2f4eae15b1428c5ddfbcdd5ac47ce4abApprove124334052021-11-07 2:35:4826 days 16 hrs ago0x07bd1f3c2197719fd8b439c01ed0e60164054e52 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0001015
0x625f8fe2e36dcbf5eef5640b5d77bff3ba4ea59b03d2a6eab862428c3fe3144aApprove124200162021-11-06 15:22:0327 days 3 hrs ago0xfeaab855c84fa881711ed74965ca4c53ffacbefe IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000123995
0xd5dac01a95c471f9b424821320e1efd0254fad2fc19485295b836d2126d7ad65Approve124197202021-11-06 15:07:1227 days 4 hrs ago0xfeaab855c84fa881711ed74965ca4c53ffacbefe IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0000725
0x44a8eff26c74c39cdca318d03219e541fd35fb9b97916e85ac0e0eb0a1b87241Approve123915282021-11-05 15:21:0128 days 3 hrs ago0x77078ba1e3ff7ab0f012e458e60389a709d86e2c IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0000725
0x5a27e332dd69d06591b19a0a222f106beb0ea2fdd309ea6a5f38b6f2482ecfe3Approve123911702021-11-05 15:01:5428 days 4 hrs ago0x723c10592e23f189793f16de04b33feb2fb36754 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0001015
0x34f31bc632bcb82e6b06a06cdbca14f18c1ac0b77a4b6eee9d74e1e2ce809604Approve123901752021-11-05 14:10:3128 days 5 hrs ago0xc88238299506cb568022e8a83e311a102007febc IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.0000725
0xf991a9bb73a29af1afd88cbf19feb6984dc0a4daa399c904b7e39c9532277fa7Approve123365262021-11-03 16:17:1130 days 3 hrs ago0x3bcca89fbaebba76906ffe2fe73496624b8b72d0 IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0xebfa2a96bb3df7086d1835e2ca47c9e79d5ca3822cabaa67de7b057b506de0baApprove123255742021-11-03 6:16:5530 days 13 hrs ago0x37e61746aeba77f38c634e4a8299d5c3fb12e60c IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
0x14f054bed11c9a47c28438c79a2be9436ccc50468d2c95cbca3b931f3688b784Approve123125402021-11-02 19:17:4531 days 2 mins ago0xfc57e202338b7448eb4ea402cff80b0a3dbb5c2c IN  0xb4abf001ec05a146696722eb50ca22763deec9a30 BNB0.000221915
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0x76ae8df7c18eead01894d85e7172b98326627223d9fc02cfa65b4369f012e286105410962021-09-01 17:04:4993 days 2 hrs ago 0x92ac8e521323c9aee4f6e74793af1b8e47fd916a  Contract Creation0 BNB
[ Download CSV Export 
Loading

Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x0d611d9ec683fcd481f775151660346948248e6a

Contract Name:
TempestToken

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-08-17
*/

// File: @openzeppelin/contracts/utils/Context.sol

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <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 GSN 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 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;
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol



pragma solidity >=0.6.0 <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/math/SafeMath.sol



pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol



pragma solidity >=0.6.0 <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 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 {_setupDecimals} is
     * called.
     *
     * 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 returns (uint8) {
        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);
        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);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        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].add(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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        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);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(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 = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(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);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(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 Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal virtual {
        _decimals = decimals_;
    }

    /**
     * @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: contracts/TempestToken.sol



pragma solidity 0.6.12;


contract TempestToken is ERC20 {
  address minter;

  modifier onlyMinter {
    require(msg.sender == minter, 'Only minter can call this function.');
    _;
  }

  constructor(address _minter) public ERC20('$TEMPEST Token', 'TEMP') {
    minter = _minter;
  }

  function mint(address account, uint256 amount) external onlyMinter {
    _mint(account, amount);
  }

  function decreaseSupply(address account, uint256 amount) external onlyMinter {
    _burn(account, amount);
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_minter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"decreaseSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

22409:498:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13464:91;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15610:169;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15610:169:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;22792:112;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;22792:112:0;;;;;;;;:::i;:::-;;14563:108;;;:::i;:::-;;;;;;;;;;;;;;;;16261:321;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;16261:321:0;;;;;;;;;;;;;;;;;:::i;14407:91::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;16991:218;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;16991:218:0;;;;;;;;:::i;22684:102::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;22684:102:0;;;;;;;;:::i;14734:127::-;;;;;;;;;;;;;;;;-1:-1:-1;14734:127:0;-1:-1:-1;;;;;14734:127:0;;:::i;13674:95::-;;;:::i;17712:269::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;17712:269:0;;;;;;;;:::i;15074:175::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15074:175:0;;;;;;;;:::i;15312:151::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15312:151:0;;;;;;;;;;:::i;13464:91::-;13542:5;13535:12;;;;;;;;-1:-1:-1;;13535:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13509:13;;13535:12;;13542:5;;13535:12;;13542:5;13535:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13464:91;:::o;15610:169::-;15693:4;15710:39;15719:12;:10;:12::i;:::-;15733:7;15742:6;15710:8;:39::i;:::-;-1:-1:-1;15767:4:0;15610:169;;;;:::o;22792:112::-;22515:6;;;;;-1:-1:-1;;;;;22515:6:0;22501:10;:20;22493:68;;;;-1:-1:-1;;;22493:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22876:22:::1;22882:7;22891:6;22876:5;:22::i;:::-;22792:112:::0;;:::o;14563:108::-;14651:12;;14563:108;:::o;16261:321::-;16367:4;16384:36;16394:6;16402:9;16413:6;16384:9;:36::i;:::-;16431:121;16440:6;16448:12;:10;:12::i;:::-;16462:89;16500:6;16462:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16462:19:0;;;;;;:11;:19;;;;;;16482:12;:10;:12::i;:::-;-1:-1:-1;;;;;16462:33:0;;;;;;;;;;;;-1:-1:-1;16462:33:0;;;:89;:37;:89::i;:::-;16431:8;:121::i;:::-;-1:-1:-1;16570:4:0;16261:321;;;;;:::o;14407:91::-;14481:9;;;;14407:91;:::o;16991:218::-;17079:4;17096:83;17105:12;:10;:12::i;:::-;17119:7;17128:50;17167:10;17128:11;:25;17140:12;:10;:12::i;:::-;-1:-1:-1;;;;;17128:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;17128:25:0;;;:34;;;;;;;;;;;:38;:50::i;22684:102::-;22515:6;;;;;-1:-1:-1;;;;;22515:6:0;22501:10;:20;22493:68;;;;-1:-1:-1;;;22493:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22758:22:::1;22764:7;22773:6;22758:5;:22::i;14734:127::-:0;-1:-1:-1;;;;;14835:18:0;14808:7;14835:18;;;;;;;;;;;;14734:127::o;13674:95::-;13754:7;13747:14;;;;;;;;-1:-1:-1;;13747:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13721:13;;13747:14;;13754:7;;13747:14;;13754:7;13747:14;;;;;;;;;;;;;;;;;;;;;;;;17712:269;17805:4;17822:129;17831:12;:10;:12::i;:::-;17845:7;17854:96;17893:15;17854:96;;;;;;;;;;;;;;;;;:11;:25;17866:12;:10;:12::i;:::-;-1:-1:-1;;;;;17854:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;17854:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;15074:175::-;15160:4;15177:42;15187:12;:10;:12::i;:::-;15201:9;15212:6;15177:9;:42::i;15312:151::-;-1:-1:-1;;;;;15428:18:0;;;15401:7;15428:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;15312:151::o;667:106::-;755:10;667:106;:::o;20859:346::-;-1:-1:-1;;;;;20961:19:0;;20953:68;;;;-1:-1:-1;;;20953:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21040:21:0;;21032:68;;;;-1:-1:-1;;;21032:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21113:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;21165:32;;;;;;;;;;;;;;;;;20859:346;;;:::o;20003:418::-;-1:-1:-1;;;;;20087:21:0;;20079:67;;;;-1:-1:-1;;;20079:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20159:49;20180:7;20197:1;20201:6;20159:20;:49::i;:::-;20242:68;20265:6;20242:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20242:18:0;;:9;:18;;;;;;;;;;;;:68;:22;:68::i;:::-;-1:-1:-1;;;;;20221:18:0;;:9;:18;;;;;;;;;;:89;20336:12;;:24;;20353:6;20336:16;:24::i;:::-;20321:12;:39;20376:37;;;;;;;;20402:1;;-1:-1:-1;;;;;20376:37:0;;;;;;;;;;;;20003:418;;:::o;18471:539::-;-1:-1:-1;;;;;18577:20:0;;18569:70;;;;-1:-1:-1;;;18569:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18658:23:0;;18650:71;;;;-1:-1:-1;;;18650:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18734:47;18755:6;18763:9;18774:6;18734:20;:47::i;:::-;18814:71;18836:6;18814:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18814:17:0;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;18794:17:0;;;:9;:17;;;;;;;;;;;:91;;;;18919:20;;;;;;;:32;;18944:6;18919:24;:32::i;:::-;-1:-1:-1;;;;;18896:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;18967:35;;;;;;;18896:20;;18967:35;;;;;;;;;;;;;18471:539;;;:::o;9456:166::-;9542:7;9578:12;9570:6;;;;9562:29;;;;-1:-1:-1;;;9562:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9609:5:0;;;9456:166::o;6629:179::-;6687:7;6719:5;;;6743:6;;;;6735:46;;;;;-1:-1:-1;;;6735:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;6799:1;6629:179;-1:-1:-1;;;6629:179:0:o;19292:378::-;-1:-1:-1;;;;;19376:21:0;;19368:65;;;;;-1:-1:-1;;;19368:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;19446:49;19475:1;19479:7;19488:6;19446:20;:49::i;:::-;19523:12;;:24;;19540:6;19523:16;:24::i;:::-;19508:12;:39;-1:-1:-1;;;;;19579:18:0;;:9;:18;;;;;;;;;;;:30;;19602:6;19579:22;:30::i;:::-;-1:-1:-1;;;;;19558:18:0;;:9;:18;;;;;;;;;;;:51;;;;19625:37;;;;;;;19558:18;;:9;;19625:37;;;;;;;;;;19292:378;;:::o;22238:92::-;;;;:::o;7091:158::-;7149:7;7182:1;7177;:6;;7169:49;;;;;-1:-1:-1;;;7169:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7236:5:0;;;7091:158::o

Swarm Source

ipfs://9f1cf0eaf2b53081d209d036ebce5dd17701948527f259e2c245b71ec70138ec
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.