Contract 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c6 1

Contract Overview

Balance:
0 CRO

CRO Value:
$0.00

Token:
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x412d1e6e3baae60d01f300c18fc1706a5fcb1ea79212ede9767d8a8eaedfc147Transfer*66964482023-01-28 5:30:17426 days 51 mins ago0x6bb7b61ed3c8cb7a433321273cdf1122dcf6ae7f IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.4824008096260
0x32fbaa00d470dedd4289947dc50d95e9f82ce33d82ba69000f3a9b76fb8c4fceTransfer*66964392023-01-28 5:29:26426 days 52 mins ago0x6bb7b61ed3c8cb7a433321273cdf1122dcf6ae7f IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.1269100161180
0x34e10dce7b375bcdc0576bf66fbd19a0d51c392bda151e02fa145be1569f3864Transfer*66964202023-01-28 5:27:39426 days 54 mins ago0x6bb7b61ed3c8cb7a433321273cdf1122dcf6ae7f IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.4824009304960
0x771dfcca43cbc1d8b79c169c2a2fe18522c9b309608f3b12c0d0e6f7d3809b75Transfer*66964122023-01-28 5:26:54426 days 55 mins ago0x6bb7b61ed3c8cb7a433321273cdf1122dcf6ae7f IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.4824009724020
0x55a22490df47ca8222fa1ffdfd0328a6a2e4c26b05840be4d59913351751ea73Transfer*66964092023-01-28 5:26:37426 days 55 mins ago0x6bb7b61ed3c8cb7a433321273cdf1122dcf6ae7f IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.4824009810810
0x4da52cdc3c80fb64df359c1145fc3554f7504a02fb1b1681d929fdf1450816b3Transfer*66963762023-01-28 5:23:29426 days 58 mins ago0x6bb7b61ed3c8cb7a433321273cdf1122dcf6ae7f IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.1404173240560
0xac27b689aba515cef032d4441df85588c44be2ed192828a18654b29da3a06ae7Transfer*66963602023-01-28 5:21:59426 days 59 mins ago0x6bb7b61ed3c8cb7a433321273cdf1122dcf6ae7f IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.4824012057830
0xbf44fcb866deecb322a6e560e9b9b35abeec5b33302debb75cd8c6e1e8ff403aTransfer*66963442023-01-28 5:20:28426 days 1 hr ago0x6bb7b61ed3c8cb7a433321273cdf1122dcf6ae7f IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.1405331409850
0x87c2f2d9a3f5a7f228524eaac0aaab34f3e615086c4200fbcc437fcd2a0c8242Transfer*66963182023-01-28 5:18:01426 days 1 hr ago0x6bb7b61ed3c8cb7a433321273cdf1122dcf6ae7f IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.2230238195210
0x926a01f2cd4beba5bc283ff9a7dd5508ef48d140827f5a9a716b1acd4d54ee52Transfer*18704932022-03-12 16:22:21747 days 13 hrs ago0xdea17fe96ace53bd7adf6a315bc31b506c82fe82 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.2017950
0x2d840aff888e6133003cacefaf171b5dddd470a1578fea13a10e713c216f0eb3Transfer*17341442022-03-03 11:08:37756 days 19 hrs ago0x10f77bfbe98b368a2504c139bdd644626bc81347 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.22180
0xf8dd080052d3f1389baf86155190ec7b1b18ea54628e2de5d56bafedc4e47913Transfer*14939262022-02-15 6:21:01773 days ago0xa694bef9ccfd0dd0d6a242c68e7bfca442c19466 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.2516556220
0x9ceb4a76295aae7da154e0dcac995d594743da8d2d9ffde38fdfcd283f23fc43Transfer*14416982022-02-11 17:31:42776 days 12 hrs ago0x36c7a3f5a4377404d5895b655dd0865d7b3d16ad IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.221740
0x7293df8753241a03529b7bad89d511b87b5ecbe2b0a86582cd595ae9a64617e5Transfer*14188352022-02-10 4:35:48778 days 1 hr ago0xa694bef9ccfd0dd0d6a242c68e7bfca442c19466 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.22180
0x88fedaf8eae74a62e5e5e7c4f7a43a94b23b3cb592b66c25bc39c56f907ab037Transfer*14175912022-02-10 2:35:34778 days 3 hrs ago0xa694bef9ccfd0dd0d6a242c68e7bfca442c19466 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.1498550
0x862bcdb92d4f08bd3ff41ea20e5390cd3670b664e4d403ce7d7da46ca18f2b36Transfer*13529572022-02-05 18:12:40782 days 12 hrs ago0x389185f3d385cee156ddc4027b13e452d38a6eaf IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.221740
0x3730499ee8b80c5962b8c8588423d82ad28a7530420a77b3f65e3d9df3c21301Transfer*13111062022-02-02 22:54:43785 days 7 hrs ago0x92921d269beb0e3d2babc5e13524581f01dfe295 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.22180
0x507c2eea57dd96aef5ca6c9aa47ff26cfe81521d29ce71d8c6555c7002cfe994Transfer*13105072022-02-02 21:56:46785 days 8 hrs ago0xfb5be8bcc0e7aa20f3931f36663ac6659defbd23 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.22180
0x4052ddfd736fb19a44e153912754112d0a837ce4b842a2f3d31d0e08f9ea29e2Transfer*13095732022-02-02 20:26:00785 days 9 hrs ago0x20b51bc96c997524ce9815627d16decbc892076d IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.2018550
0xe9d15a61a7dbf2097115070fe759757db3c5a8658d2a24f5aa092f0e518a8b28Transfer*13070752022-02-02 16:24:09785 days 13 hrs ago0xa694bef9ccfd0dd0d6a242c68e7bfca442c19466 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.1490750
0x056f453dadd09014feda2563bbeb08380d83b3b377dfb233425442b30d134a7aTransfer*12967462022-02-01 23:48:47786 days 6 hrs ago0xf3d3e30cf73afc65781f5eedc517866c1471b638 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.22180
0xdc25f69619b3565df37edf0b9e76b42f51db381ec4e8284e75226984c8edaac7Transfer*12918882022-02-01 15:59:42786 days 14 hrs ago0x8cdca040554c5ccc22b202a621f31c0e908d9d6b IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.2017950
0xa54f520671466e21088f16e85ad4a94a69c4a44a4fb7174d035f60c4ddc66a92Transfer*12733472022-01-31 10:07:20787 days 20 hrs ago0xa694bef9ccfd0dd0d6a242c68e7bfca442c19466 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.1490750
0xb59102270282629edf20360c1139e679378e9cd50870011fa0c2a9ff267a40b5Transfer*12725992022-01-31 8:55:15787 days 21 hrs ago0x20b51bc96c997524ce9815627d16decbc892076d IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.2018550
0x14cc1d0231e569ac2d376d642852b49d322b8f9345caf760e5a699cf209c5adaTransfer*12710882022-01-31 6:29:46787 days 23 hrs ago0xa694bef9ccfd0dd0d6a242c68e7bfca442c19466 IN 0x72f9c71f6616a91f46a1ccaedab84cdaabfff3c60 CRO0.1268550
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0xe8f506f2fac4462c102b9ff4bdf33a71e8712d10214a8fd339d54bbc5ac37a0612411122022-01-29 6:09:11790 days 12 mins ago 0xb3548a9330296a7ef8e4ab0e25a3c21fbc08e909  Contract Creation0 CRO
[ Download CSV Export 
Index Block
Loading

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0xf43c17BBD2FE5e79A2f469e988D57152bb86Ecbf
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
standardToken

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 1 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at cronoscan.com on 2022-01-08
*/

// Sources flattened with hardhat v2.7.0 https://hardhat.org

// File contracts/StandardToken.sol

pragma solidity ^0.6.12;

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

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

/*
 * @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;
    }
}

/**
 * @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, 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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * 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);
        uint256 c = a - b;

        return c;
    }

    /**
     * @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) {
        // 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 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message 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,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

/**
 * @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.
 */
contract Ownable is Context {
    address private _owner;
    address private _previousOwner;
    uint256 private _lockTime;

    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() public {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view 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;
    }

    function geUnlockTime() public view returns (uint256) {
        return _lockTime;
    }

    //Locks the contract for owner for the amount of time provided
    function lock(uint256 time) public virtual onlyOwner {
        _previousOwner = _owner;
        _owner = address(0);
        _lockTime = block.timestamp + time;
        emit OwnershipTransferred(_owner, address(0));
    }

    //Unlocks the contract for owner when _lockTime is exceeds
    function unlock() public virtual {
        require(
            _previousOwner == msg.sender,
            "You don't have permission to unlock"
        );
        require(block.timestamp > _lockTime, "Contract is locked until 7 days");
        emit OwnershipTransferred(_owner, _previousOwner);
        _owner = _previousOwner;
    }
}

contract standardToken is Context, IERC20, IERC20Metadata, Ownable {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;
    bool public generatedUsingDxMint = true;
    uint256 private _totalSupply;
    bool public mintingFinishedPermanent = false;
    string private _name;
    string private _symbol;
    uint8 private _decimals;
    address public _creator;

    /**
     * @dev Sets the values for {name}, {symbol} and {decimals}.
     *
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(
        address creator_,
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        uint256 tokenSupply_
    ) public {
        _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
        _creator = creator_;

        _mint(_creator, tokenSupply_);
        mintingFinishedPermanent = true;
    }

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

        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:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(!mintingFinishedPermanent, "cant be minted anymore!");
        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 {}
}

Contract ABI

[{"inputs":[{"internalType":"address","name":"creator_","type":"address"},{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint8","name":"decimals_","type":"uint8"},{"internalType":"uint256","name":"tokenSupply_","type":"uint256"}],"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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","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":[],"name":"_creator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"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":[],"name":"geUnlockTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"generatedUsingDxMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"uint256","name":"time","type":"uint256"}],"name":"lock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintingFinishedPermanent","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","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"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unlock","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Deployed Bytecode

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

Deployed ByteCode Sourcemap

12938:10495:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14040:100;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16355:210;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;16355:210:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;15167:108;;;:::i;:::-;;;;;;;;;;;;;;;;17047:493;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;17047:493:0;;;;;;;;;;;;;;;;;:::i;15002:100::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;17949:297;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;17949:297:0;;;;;;;;:::i;15338:177::-;;;;;;;;;;;;;;;;-1:-1:-1;15338:177:0;-1:-1:-1;;;;;15338:177:0;;:::i;11535:148::-;;;:::i;:::-;;13140:39;;;:::i;10893:79::-;;;:::i;:::-;;;;-1:-1:-1;;;;;10893:79:0;;;;;;;;;;;;;;14259:104;;;:::i;18749:446::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;18749:446:0;;;;;;;;:::i;12590:341::-;;;:::i;15728:216::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15728:216:0;;;;;;;;:::i;12127:89::-;;;:::i;13358:23::-;;;:::i;12292:226::-;;;;;;;;;;;;;;;;-1:-1:-1;12292:226:0;;:::i;16007:201::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;16007:201:0;;;;;;;;;;:::i;11838:281::-;;;;;;;;;;;;;;;;-1:-1:-1;11838:281:0;-1:-1:-1;;;;;11838:281:0;;:::i;13221:44::-;;;:::i;14040:100::-;14127:5;14120:12;;;;;;;;-1:-1:-1;;14120:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14094:13;;14120:12;;14127:5;;14120:12;;14127:5;14120:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14040:100;:::o;16355:210::-;16474:4;16496:39;16505:12;:10;:12::i;:::-;16519:7;16528:6;16496:8;:39::i;:::-;-1:-1:-1;16553:4:0;16355:210;;;;:::o;15167:108::-;15255:12;;15167:108;:::o;17047:493::-;17187:4;17204:36;17214:6;17222:9;17233:6;17204:9;:36::i;:::-;-1:-1:-1;;;;;17280:19:0;;17253:24;17280:19;;;:11;:19;;;;;17253:24;17300:12;:10;:12::i;:::-;-1:-1:-1;;;;;17280:33:0;-1:-1:-1;;;;;17280:33:0;;;;;;;;;;;;;17253:60;;17366:6;17346:16;:26;;17324:116;;;;-1:-1:-1;;;17324:116:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17451:57;17460:6;17468:12;:10;:12::i;:::-;17501:6;17482:16;:25;17451:8;:57::i;:::-;-1:-1:-1;17528:4:0;;17047:493;-1:-1:-1;;;;17047:493:0:o;15002:100::-;15085:9;;;;15002:100;:::o;17949:297::-;18064:4;18086:130;18109:12;:10;:12::i;:::-;18136:7;18195:10;18158:11;:25;18170:12;:10;:12::i;:::-;-1:-1:-1;;;;;18158:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;18158:25:0;;;:34;;;;;;;;;;:47;18086:8;:130::i;15338:177::-;-1:-1:-1;;;;;15489:18:0;15457:7;15489:18;;;:9;:18;;;;;;;15338:177::o;11535:148::-;11115:12;:10;:12::i;:::-;11105:6;;-1:-1:-1;;;;;11105:6:0;;;:22;;;11097:67;;;;;-1:-1:-1;;;11097:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;11097:67:0;;;;;;;;;;;;;;;11642:1:::1;11626:6:::0;;11605:40:::1;::::0;-1:-1:-1;;;;;11626:6:0;;::::1;::::0;-1:-1:-1;;;;;;;;;;;11605:40:0;11642:1;;11605:40:::1;11673:1;11656:19:::0;;-1:-1:-1;;;;;;11656:19:0::1;::::0;;11535:148::o;13140:39::-;;;;;;:::o;10893:79::-;10931:7;10958:6;-1:-1:-1;;;;;10958:6:0;10893:79;:::o;14259:104::-;14348:7;14341:14;;;;;;;;-1:-1:-1;;14341:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14315:13;;14341:14;;14348:7;;14341:14;;14348:7;14341:14;;;;;;;;;;;;;;;;;;;;;;;;18749:446;18869:4;18891:24;18918:11;:25;18930:12;:10;:12::i;:::-;-1:-1:-1;;;;;18918:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;18918:25:0;;;:34;;;;;;;;;;;-1:-1:-1;18985:35:0;;;;18963:122;;;;-1:-1:-1;;;18963:122:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19096:67;19105:12;:10;:12::i;:::-;19119:7;19147:15;19128:16;:34;19096:8;:67::i;:::-;-1:-1:-1;19183:4:0;;18749:446;-1:-1:-1;;;18749:446:0:o;12590:341::-;12656:14;;-1:-1:-1;;;;;12656:14:0;12674:10;12656:28;12634:113;;;;-1:-1:-1;;;12634:113:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12784:9;;12766:15;:27;12758:71;;;;;-1:-1:-1;;;12758:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12874:14;;;12866:6;;12845:44;;-1:-1:-1;;;;;12874:14:0;;;;12866:6;;;;-1:-1:-1;;;;;;;;;;;12845:44:0;;12909:14;;;12900:23;;-1:-1:-1;;;;;;12900:23:0;-1:-1:-1;;;;;12909:14:0;;;12900:23;;;;;;12590:341::o;15728:216::-;15850:4;15872:42;15882:12;:10;:12::i;:::-;15896:9;15907:6;15872:9;:42::i;12127:89::-;12199:9;;12127:89;:::o;13358:23::-;;;;;;-1:-1:-1;;;;;13358:23:0;;:::o;12292:226::-;11115:12;:10;:12::i;:::-;11105:6;;-1:-1:-1;;;;;11105:6:0;;;:22;;;11097:67;;;;;-1:-1:-1;;;11097:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;11097:67:0;;;;;;;;;;;;;;;12373:6:::1;::::0;;;12356:23;;-1:-1:-1;;;;;;12356:23:0;;::::1;-1:-1:-1::0;;;;;12373:6:0;::::1;12356:23;::::0;;;12390:19:::1;::::0;;12432:15:::1;:22:::0;::::1;12420:9;:34:::0;12470:40:::1;::::0;12373:6;;-1:-1:-1;;;;;;;;;;;12470:40:0;12373:6;;12470:40:::1;12292:226:::0;:::o;16007:201::-;-1:-1:-1;;;;;16173:18:0;;;16141:7;16173:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;16007:201::o;11838:281::-;11115:12;:10;:12::i;:::-;11105:6;;-1:-1:-1;;;;;11105:6:0;;;:22;;;11097:67;;;;;-1:-1:-1;;;11097:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;11097:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;11941:22:0;::::1;11919:110;;;;-1:-1:-1::0;;;11919:110:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12066:6;::::0;;12045:38:::1;::::0;-1:-1:-1;;;;;12045:38:0;;::::1;::::0;12066:6;::::1;::::0;-1:-1:-1;;;;;;;;;;;12045:38:0;::::1;12094:6;:17:::0;;-1:-1:-1;;;;;;12094:17:0::1;-1:-1:-1::0;;;;;12094:17:0;;;::::1;::::0;;;::::1;::::0;;11838:281::o;13221:44::-;;;;;;:::o;4042:98::-;4122:10;4042:98;:::o;22322:380::-;-1:-1:-1;;;;;22458:19:0;;22450:68;;;;-1:-1:-1;;;22450:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22537:21:0;;22529:68;;;;-1:-1:-1;;;22529:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22610:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;22662:32;;;;;;;;;;;;;;;;;22322:380;;;:::o;19685:675::-;-1:-1:-1;;;;;19825:20:0;;19817:70;;;;-1:-1:-1;;;19817:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19906:23:0;;19898:71;;;;-1:-1:-1;;;19898:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19982:47;20003:6;20011:9;20022:6;19982:20;:47::i;:::-;-1:-1:-1;;;;;20066:17:0;;20042:21;20066:17;;;:9;:17;;;;;;20116:23;;;;20094:111;;;;-1:-1:-1;;;20094:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;20216:17:0;;;;;;;:9;:17;;;;;;;;20236:22;;;20216:42;;20269:20;;;;;;;;;;:30;;;;;;20317:35;;;;;;;20269:20;;20317:35;;;;;;;;;;;19685:675;;;;:::o;23305:125::-;;;;:::o

Swarm Source

ipfs://eeba8997397fbb46e7d3d35fe9aa1b79b8c8a1704029eb096fa78c63a25af27e
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.