Contract 0xe3894cb9e92ca78524fb6a30ff072fa5e533c162 3

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xf6e0a78b1b4fd29c111aa6c11be82d7bb57a88da469ef8acd7446b7e4b78f947Approve132724042021-12-07 13:09:105 hrs 15 mins ago0xe12e628c5a2be6a4d457a94f4575c61184293052 IN  Cycan Network: ELP Token0 BNB0.000132798645
0x7ee97ecef75f21996661e0dbcafd443d50e050f29846e3019bd5228ee8ff1171Transfer132702652021-12-07 11:09:467 hrs 15 mins ago0x7925333d9d8b16101b0f921c24eb069d02a4dc81 IN  Cycan Network: ELP Token0 BNB0.000105995
0x0d74099d1ad26040b46793d159a38d55a5d0f7ca416c1ca51dc184c8f945b211Transfer132693552021-12-07 10:23:208 hrs 1 min ago0x643ce4d318234863e48e26b59c4e4e17b99fa721 IN  Cycan Network: ELP Token0 BNB0.000180995
0x796beba097a8a4b7b3a7a325f09be6ea287fd85c0a777b10afe2842f0e79d265Transfer132693022021-12-07 10:20:398 hrs 4 mins ago0x1495f2e798b490d54835a39885d891fb92005869 IN  Cycan Network: ELP Token0 BNB0.000181055
0xab90193b5b191be45fb8f35e9de832984c1cd970be91ba1cbc10e1766e55f958Transfer132684422021-12-07 9:37:188 hrs 47 mins ago0xe358e6529a5a0dd46d6704a391ac1c11601e2a60 IN  Cycan Network: ELP Token0 BNB0.00022168476
0xcf0711a572951b217a69c0ae9e5355bfbe79278994671383d7cfb362bceaa7ebApprove132681742021-12-07 9:23:249 hrs 1 min ago0xc06ac56e04a2ae14ecf6a33865954f85f4ab7975 IN  Cycan Network: ELP Token0 BNB0.000221915
0x5e9c4245e5b92e21cddf03022bd4d25f859780f20876155de50537a6ac67f41bApprove132681232021-12-07 9:20:449 hrs 4 mins ago0x41637bf0295da222bc0c6975a952ad4bd0102ab6 IN  Cycan Network: ELP Token0 BNB0.000221915
0x14f5e5b98934d63e8f7182c1cd34ed1f3c88ae2e24c9561e906ac7e8c17446daTransfer132680972021-12-07 9:19:269 hrs 5 mins ago0xf20d5ddebaa4ca96d2943a4b46e8b07b3c315f4b IN  Cycan Network: ELP Token0 BNB0.000181115
0x30f39425b7aab0b9648385e9539acba70f213c583064538ea68d1242cfed8fb6Transfer132675102021-12-07 8:50:039 hrs 34 mins ago0x27a2fed6dc0910eb368dcd475abc9d9a81b21926 IN  Cycan Network: ELP Token0 BNB0.000181055
0xfbd3835db3b7786103be65310d037c76c8239b28985e4be373fe2b91bfda6c1dTransfer132674822021-12-07 8:48:399 hrs 36 mins ago0x27a2fed6dc0910eb368dcd475abc9d9a81b21926 IN  Cycan Network: ELP Token0 BNB0.000256055
0xc3c6e5077d774b62c18e3b6321d418c5a8d85224d1ebe8e33b1b0d16eca916b2Transfer132648872021-12-07 6:35:0811 hrs 49 mins ago0xf05eb18f422e4641d34dfe3e503b5fa62dda60d5 IN  Cycan Network: ELP Token0 BNB0.000113584905
0xb63642f644791f6359bc51e1a5ad6fa119da5e7ea8e72ccdde3ba55fcd1f7b0cTransfer132614832021-12-07 3:40:0714 hrs 44 mins ago0x0a37a441b5161f54cddc3822dacbe188f305d722 IN  Cycan Network: ELP Token0 BNB0.000358477
0x5b9a8f57d83f8119292278e69ed67a600e3a781cce043f9c402e08b3d87d0a2dApprove132597782021-12-07 2:11:5516 hrs 13 mins ago0x97bd2e324e8a235bfd5bcf85da53f88ffb77da74 IN  Cycan Network: ELP Token0 BNB0.000151098
0xd63289eea6ea92fc990f940d6c399b2e8a404d2cc91e246d38ddd5bea99cb7e3Approve132597742021-12-07 2:11:4316 hrs 13 mins ago0x97bd2e324e8a235bfd5bcf85da53f88ffb77da74 IN  Cycan Network: ELP Token0 BNB0.000266298
0x06701e8783a66d0097286b285511cf18ef6166e59180a94335700d2fbefb89cfApprove132533532021-12-06 20:48:2421 hrs 36 mins ago0x9e5296fd4fbcaee0a1d1ea6220c7b339db72b6bf IN  Cycan Network: ELP Token0 BNB0.000221915
0x689bd9393b84e5fc219fef17111c3d4a83381d9d9c0f6e627fbecb9390e991d8Transfer132475892021-12-06 15:52:241 day 2 hrs ago0x1aa5a55f6d79ad3bd84bb5e3a1a7d9ecec8edba3 IN  Cycan Network: ELP Token0 BNB0.000106175
0x1fd129d9bd0cd7149f55a95f4cbcadc4ddb9f5e58db716a26ed5c9f9ac1afdceTransfer132475682021-12-06 15:51:201 day 2 hrs ago0x5205534a5395c14ca934cde8751e55dee376423f IN  Cycan Network: ELP Token0 BNB0.000307338
0xbfc519b2535c4c23feba975cccfc3a0f713d2e95b7b64c86f838a425dde65f3aApprove132421902021-12-06 11:02:271 day 7 hrs ago0x00443e320755c1ebc359b6e8606338ebaa7b5009 IN  Cycan Network: ELP Token0 BNB0.000221915
0x2fbbb40d9d06cdf1f5af2042612d33078357ba81313bd0e3d547aa9bf51a96feTransfer132406132021-12-06 9:42:081 day 8 hrs ago0x8dd333989859b6564bf364559143bd3189b8b0e9 IN  Cycan Network: ELP Token0 BNB0.000106175
0x497eaeb298cd7fc4e9d0c2fd00dd14188a65a2fe919c960d66c4ca54d2fcb82eTransfer132406042021-12-06 9:41:371 day 8 hrs ago0x475da02e5c3f5914649aa59b0bd9a734b63cff3e IN  Cycan Network: ELP Token0 BNB0.000106175
0x00f0c21bc2166f1aa3ad69d5f63c0f4cc0c15e52fcc9501ce65032236db8e8a4Transfer132405962021-12-06 9:41:091 day 8 hrs ago0xe4e0a3e2dd34fe76d7b4e18dacf559b1bde49751 IN  Cycan Network: ELP Token0 BNB0.000106175
0xd847499bd7f265c615f5bcfcbf28872de13e62c2a82ee2fc1c27327fb6940a75Transfer132405862021-12-06 9:40:361 day 8 hrs ago0xe58463fd7d4acf2ca4fe92eae2344b836b76c1af IN  Cycan Network: ELP Token0 BNB0.000106175
0x6985d8d9903a1f51c6c806b01ca629ad31a794bb522b0be388718d73dd8b45aeTransfer132405772021-12-06 9:40:061 day 8 hrs ago0x2839691e39f00d8e69700606dc262b82e21cf99c IN  Cycan Network: ELP Token0 BNB0.000106175
0x960559583ea81b0f437f9c70e0676c85c040d2d6718fe349a986d52073975a12Transfer132405702021-12-06 9:39:451 day 8 hrs ago0xd043dcf6d5a5dcfc262e41fe44ae04b26b567050 IN  Cycan Network: ELP Token0 BNB0.000106175
0xfc2590aadc690bc299de178c1d192dfa0a544351d5f64fccc6cc95ecf97984aaTransfer132405582021-12-06 9:39:081 day 8 hrs ago0xc1d64e067a15db93566d614738934ef89e25c292 IN  Cycan Network: ELP Token0 BNB0.000106175
[ Download CSV Export 

OVERVIEW

Everlasting Parachain(ELP) is the canary network of the Cycan network. The ELP is based on Polkadot's canary network Kusama. The goal of the Cycan network is to build a decentralized asset management protocol based on the Substrate framework.

Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ERC20

Compiler Version
v0.7.4+commit.3f05b770

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-03-23
*/

// SPDX-License-Identifier: MIT

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, 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 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;
    }
}

/**
 * @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 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 = 'Everlasting Parachain Token';
    string private _symbol = 'ELP';
    uint8 private _decimals = 18;

    /**
     * @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 () public {
        _mint(msg.sender, 10000000*1e18);
    }
    
    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view 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 returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view 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 { }
}

Contract Security Audit

Contract ABI

[{"inputs":[],"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":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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

10169:9679:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11019:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13125:169;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;13125:169:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;12094:100;;;:::i;:::-;;;;;;;;;;;;;;;;13776:321;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;13776:321:0;;;;;;;;;;;;;;;;;:::i;11946:83::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14506:218;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;14506:218:0;;;;;;;;:::i;12257:119::-;;;;;;;;;;;;;;;;-1:-1:-1;12257:119:0;-1:-1:-1;;;;;12257:119:0;;:::i;11221:87::-;;;:::i;15227:269::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;15227:269:0;;;;;;;;:::i;12589:175::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;12589:175:0;;;;;;;;:::i;12827:151::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;12827:151:0;;;;;;;;;;:::i;11019:83::-;11089:5;11082:12;;;;;;;;-1:-1:-1;;11082:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11056:13;;11082:12;;11089:5;;11082:12;;11089:5;11082:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11019:83;:::o;13125:169::-;13208:4;13225:39;13234:12;:10;:12::i;:::-;13248:7;13257:6;13225:8;:39::i;:::-;-1:-1:-1;13282:4:0;13125:169;;;;:::o;12094:100::-;12174:12;;12094:100;:::o;13776:321::-;13882:4;13899:36;13909:6;13917:9;13928:6;13899:9;:36::i;:::-;13946:121;13955:6;13963:12;:10;:12::i;:::-;13977:89;14015:6;13977:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;13977:19:0;;;;;;:11;:19;;;;;;13997:12;:10;:12::i;:::-;-1:-1:-1;;;;;13977:33:0;;;;;;;;;;;;-1:-1:-1;13977:33:0;;;:89;:37;:89::i;:::-;13946:8;:121::i;:::-;-1:-1:-1;14085:4:0;13776:321;;;;;:::o;11946:83::-;12012:9;;;;11946:83;:::o;14506:218::-;14594:4;14611:83;14620:12;:10;:12::i;:::-;14634:7;14643:50;14682:10;14643:11;:25;14655:12;:10;:12::i;:::-;-1:-1:-1;;;;;14643:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;14643:25:0;;;:34;;;;;;;;;;;:38;:50::i;12257:119::-;-1:-1:-1;;;;;12350:18:0;12323:7;12350:18;;;;;;;;;;;;12257:119::o;11221:87::-;11293:7;11286:14;;;;;;;;-1:-1:-1;;11286:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11260:13;;11286:14;;11293:7;;11286:14;;11293:7;11286:14;;;;;;;;;;;;;;;;;;;;;;;;15227:269;15320:4;15337:129;15346:12;:10;:12::i;:::-;15360:7;15369:96;15408:15;15369:96;;;;;;;;;;;;;;;;;:11;:25;15381:12;:10;:12::i;:::-;-1:-1:-1;;;;;15369:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;15369:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;12589:175::-;12675:4;12692:42;12702:12;:10;:12::i;:::-;12716:9;12727:6;12692:9;:42::i;12827:151::-;-1:-1:-1;;;;;12943:18:0;;;12916:7;12943:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;12827:151::o;910:181::-;968:7;1000:5;;;1024:6;;;;1016:46;;;;;-1:-1:-1;;;1016:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1082:1;910:181;-1:-1:-1;;;910:181:0:o;5913:106::-;6001:10;5913:106;:::o;18374:346::-;-1:-1:-1;;;;;18476:19:0;;18468:68;;;;-1:-1:-1;;;18468:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18555:21:0;;18547:68;;;;-1:-1:-1;;;18547:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18628:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;18680:32;;;;;;;;;;;;;;;;;18374:346;;;:::o;15986:539::-;-1:-1:-1;;;;;16092:20:0;;16084:70;;;;-1:-1:-1;;;16084:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16173:23:0;;16165:71;;;;-1:-1:-1;;;16165:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16249:47;16270:6;16278:9;16289:6;16249:20;:47::i;:::-;16329:71;16351:6;16329:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16329:17:0;;:9;:17;;;;;;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;16309:17:0;;;:9;:17;;;;;;;;;;;:91;;;;16434:20;;;;;;;:32;;16459:6;16434:24;:32::i;:::-;-1:-1:-1;;;;;16411:20:0;;;:9;:20;;;;;;;;;;;;:55;;;;16482:35;;;;;;;16411:20;;16482:35;;;;;;;;;;;;;15986:539;;;:::o;1813:192::-;1899:7;1935:12;1927:6;;;;1919:29;;;;-1:-1:-1;;;1919:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1971:5:0;;;1813:192::o;19753:92::-;;;;:::o

Swarm Source

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